diff --git a/.agents/skills/github-pr-mirror/SKILL.md b/.agents/skills/github-pr-mirror/SKILL.md new file mode 100644 index 0000000000..e04c567727 --- /dev/null +++ b/.agents/skills/github-pr-mirror/SKILL.md @@ -0,0 +1,153 @@ +--- +name: github-pr-mirror +description: Mirror an external GitHub pull request into the internal GraalPython Bitbucket review flow, including OCA label checks, Jira creation or reuse, preserving PR commits, pre-commit cleanup, and handoff to the shared GraalPython Bitbucket PR flow for PR creation, Graal Bot tasks, gates, and fixes. +--- + +# GitHub PR Mirror + +Use this skill when asked to mirror, import, port, or copy a GitHub pull request into Bitbucket for GraalPython review. + +This workflow intentionally preserves the original GitHub PR commits. Do not rebase, squash, amend, or otherwise rewrite the contributor's commits unless the user explicitly tells you to abandon GitHub auto-closing behavior. + +## Companion Skills + +- Use the `jira` skill when creating or transitioning Jira issues. +- Use the `graalpython-bitbucket-pr` skill after the mirror branch is ready, to create the Bitbucket PR, handle Graal Bot tasks, start/watch gates, and fix or report gate failures. + +## Inputs + +Required: +- GitHub PR number or URL. + +Optional: +- Existing Jira issue key, such as `GR-12345`. +- Bitbucket target branch. Default to the GitHub PR base branch, normally `master`. +- Bitbucket remote. Default to `origin`. +- GitHub remote. Default to `github`; if absent, use the remote matching `github.com/graalvm/graalpython`. +- Bitbucket project/repository. Default to `G` / `graalpython`. + +## Workflow + +### 1. Inspect the GitHub PR and verify OCA + +Fetch GitHub PR metadata without modifying the repository: + +```bash +gh pr view --repo graalvm/graalpython --json number,title,url,labels,baseRefName,headRefOid +``` + +Abort if the labels do not include exactly `OCA Verified`. Tell the user the PR is not mirrorable yet because OCA is missing. + +Record: +- `PR_NUMBER` +- `PR_TITLE` +- `PR_URL` +- `BASE_BRANCH` +- `HEAD_SHA` + +### 2. Create or reuse the Jira issue + +If the user supplied a Jira issue, use it. Otherwise create one: + +- Project: `GR` +- Component: `Python` +- Summary: `GitHub PR#: ` +- Description: the GitHub PR URL only +- Assignee: current user. If not already known, derive from `git config user.email` + +Use a temporary JSON template for `gdev-cli jira create`, then remove the template after creation. Adapt the assignee field to the accepted Jira schema if the CLI rejects the first attempt. + +Example template shape: + +```json +{ + "fields": { + "project": { "key": "GR" }, + "summary": "GitHub PR#: ", + "description": "", + "issuetype": { "name": "Task" }, + "components": [{ "name": "Python" }], + "assignee": { "emailAddress": "" } + } +} +``` + +After creation or reuse, transition the issue to In Progress: + +```bash +gdev-cli jira transition --issues -t "Start Progress" --force +``` + +If Jira reports a different valid transition name for starting work, use that name. + +### 3. Fetch the PR and create the mirror branch + +Use a branch named exactly: + +```text +github-pr/ +``` + +Do not reuse a dirty or unrelated branch. If the branch already exists, inspect it; only continue if it already points at the same GitHub PR history or the user confirms replacement. + +Fetch and branch from the GitHub PR head: + +```bash +git fetch pull//head +git switch -c github-pr/ FETCH_HEAD +``` + +Verify `HEAD` is the GitHub PR head SHA from step 1: + +```bash +test "$(git rev-parse HEAD)" = "" +``` + +Do not rebase. Do not squash. Do not amend original commits. + +Check that there are no merge conflicts using `git merge-tree`. If there are, fetch and merge the target branch without fast-forwarding and resolve the conflicts. + +### 4. Run pre-commit on the PR range + +Fetch the base branch and compute the original PR commit range: + +```bash +git fetch +BASE_REF="$(git merge-base HEAD /)" +pre-commit run --from-ref "$BASE_REF" --to-ref HEAD +``` + +If pre-commit modified files, review the diff and create a new follow-up commit on top of the GitHub PR commits: + +```bash +git status --short +git diff +git add +git commit -m "[GR-] Apply pre-commit fixes for GitHub PR#" +``` + +Only commit mechanical pre-commit output here. If pre-commit reveals non-mechanical problems, fix them in a separate follow-up commit when trivial; otherwise stop and ask the user. + +### 5. Create the Bitbucket PR and follow gates + +Use the `graalpython-bitbucket-pr` skill with these inputs: +- Source branch: `github-pr/` +- Bitbucket remote: `` +- Target branch: `` +- Title: `[] GitHub PR#: ` +- Description: `Mirrors GitHub for internal review.` +- Project/repository: `G` / `graalpython` +- Reviewers: repo-level default reviewers + +Let that skill create the PR, handle Graal Bot comments/tasks, start or verify gates, watch gates, and fix or report failures. + +## Final Report + +Always report: +- Bitbucket PR URL +- Jira issue key or URL +- Gate status and any unresolved failures or bot tasks + +## Guardrails +- Don't comment on the github PR unless asked. Never mention the internal bitbucket/buildbot/etc URLs in comments on github. +- After handing off to `graalpython-bitbucket-pr`, do not stop monitoring the gates until they finish, fail, or become blocked by tooling. diff --git a/.agents/skills/graalpython-bitbucket-pr/SKILL.md b/.agents/skills/graalpython-bitbucket-pr/SKILL.md new file mode 100644 index 0000000000..af57a9e896 --- /dev/null +++ b/.agents/skills/graalpython-bitbucket-pr/SKILL.md @@ -0,0 +1,124 @@ +--- +name: graalpython-bitbucket-pr +description: Create or continue a GraalPython Bitbucket pull request and drive it through Graal Bot tasks, gate start, gate monitoring, failure investigation, fixes, pushes, and gate reruns. Use after a branch is ready for internal GraalPython review, or when an automation command has already created the PR and the remaining work is task cleanup and gate follow-up. +--- + +# GraalPython Bitbucket PR + +## Overview +Create or continue a GraalPython Bitbucket PR, resolve administrative Graal Bot tasks, start or verify gates, watch gates, and fix or report failures. + +## Companion Skills +- Use the `bitbucket` skill for PR creation, comments, and tasks. +- Use the `buildbot` skill for starting, watching, rerunning, and investigating gates. + +## Inputs +Required for new PRs: +- Source branch already pushed or ready to push. +- Target branch. +- PR title. +- PR description. +- Jira key in the PR title. + +Required for existing PRs: +- Bitbucket PR ID or URL. + +Defaults: +- Project/repository: `G` / `graalpython`. +- Reviewers: use the repo-level default reviewers unless the caller supplies a different list. +- Target branch: master + +## Workflow + +### 1. Push and create the PR, if needed + +If the source branch is not pushed yet: + +```bash +git push +``` + +Create the Bitbucket PR: + +```bash +gdev-cli bitbucket create-pr \ + -p G \ + -r graalpython \ + -fb \ + -tb \ + -t "" \ + -rv "" \ + -d "" \ + --gate +``` + +Capture the Bitbucket PR URL and ID. If `--gate` is not accepted or fails transiently, create the PR first, then start gates with: + +```bash +gdev-cli buildbot start-gate -p G -r graalpython -pr +``` + +If the PR already exists, capture the PR URL and ID, then continue with task handling and gate checks. + +### 2. Handle Graal Bot comments and tasks + +Wait about 15 seconds after PR creation, then list comments and tasks: + +```bash +gdev-cli bitbucket comment list -p G -r graalpython -pr --all --json +gdev-cli bitbucket task list -p G -r graalpython -pr --json +``` + +For tasks or comments authored by Graal Bot: +- Resolve tasks that are clearly administrative and already satisfied by the PR workflow. +- There should be a task regarding changelog. Changelog items are usually not needed for bugfixes and compatibility improvements. + They are needed for added context options, changed public API's in `polyglot` module or large features. If a changelog item is needed + but not present, suggest one and notify the user. + +Resolve a task only when justified: + +```bash +gdev-cli bitbucket task resolve -p G -r graalpython -pr -cm +``` + +### 3. Watch gates + +Use sparse polling because full gates can take about an hour. Prefer structured output for status decisions: + +```bash +gdev-cli buildbot gate-overview -p G -r graalpython -pr --json +gdev-cli buildbot gate-builds -p G -r graalpython -pr --json +``` + +Human-readable output is fine for reporting, but avoid parsing it when JSON is available. + +Suggested cadence: +- First check after PR creation and bot handling. +- Then every 10 minutes while many jobs are running. +- When fewer than about 5 jobs remain, poll every 5 minutes. +- Poll silently while gates are still running. +- If there are failures, try to diagnose them as soon as they appear. + +Treat the gate as successful only when there are no running and no failed gate builds. Other PR vetoes, such as reviewer approval, merge queue state, or GitHub mirroring consideration, are not gate failures. + +### 4. Fix or report gate failures + +If gates fail: +- Inspect failing build logs with the `buildbot` skill. +- Fix trivial issues yourself, such as style output, generated pre-commit fallout, missing `@TruffleBoundary`, obvious test-selector mistakes, or small import/order problems. +- Commit fixes on top of the PR branch, push again, and restart or rerun gates as appropriate. +- Report non-trivial semantic failures, broad compatibility failures, or failures that require product judgment to the user with the Bitbucket PR URL, Jira key, and concise failure summary. +- Many gate failures are transient. Use your judgement to determine if a failure might be transient and if it's the case, restart the gate and go back to polling. +- Typical signs of a transient failure: + - Infrastructure issues in the worker setup, git checkout or cleanup + - Single failed test on a single platform that succeeded on other platforms + - Test failures in tests involving weakrefs, subprocesses or multi-threading in PRs that didn't touch those subsystems. + +Do not leave a long sleep process running after an interruption or handoff. If monitoring is interrupted, clean up any background sleep/polling process you started, then resume with a fresh status check. + +## Final Report +Always report: +- Bitbucket PR URL +- Gate status +- Any unresolved failures or Graal Bot tasks +- Any transient issues encountered, with links to failed builds diff --git a/.agents/skills/jira/SKILL.md b/.agents/skills/jira/SKILL.md new file mode 100644 index 0000000000..9d170658ff --- /dev/null +++ b/.agents/skills/jira/SKILL.md @@ -0,0 +1,171 @@ +--- +name: jira +description: Deal with Jira tickets autonomously +--- + +# Jira + +## Overview + +Deal with Jira tickets, pull their description and any linked context, search, +update, reproduce, potentially fix and/or close them. Go on with this workflow +to the end unless you are actually blocked or get to one of the points where +the workflow tells you to wait for confirmation or ask something. + +### General Notes + +Typical fields you need to know: +* "components" is typically one of "Python", "Mx", "Infra", "Compiler", "Truffle" +* "issuetype" is typically "Task", "Bug (non BugDB)", "Testing", "Build Failure" +* "project" is typically "GR" +* "labels" is typically left empty when creating new issues + +### 1. Getting context + +To get the issue data, start with `gdev-cli`, for example: + + gdev-cli jira get-issue --json -id GR-72840 + +Read the description and follow any links that seem relevant. + +Run this in a subagent if possible and let it give you a summary. + +### 2. Check if there is work to do + +Issues may be stale, already solved, or no longer apply. Search the context and +logs for other potentially relevant keywords, use `gdev-cli jira search` to find +out if there are potentially other related issues, query the codebase and git +history and look for reproducers. + +Run this in a subagent if possible and let it give you a summary. + +### 3. Reproduce the issue + +It is PARAMOUNT to reproduce an issue first before changing code. You should +not give up trying to reproduce an issue until you are certain that it *cannot* +be reproduced or you spent at least a few hours and a million tokens on it. If +after that amount of work you have not reproduced the issue, STOP AND ASK for +guidance. + +Derive how to reproduce the issue from the logs and issues you find. This may +mean running existing tests in a loop if the issue appears transient, or +writing a new test in `graalpython/com.oracle.graal.python.tests/src/tests` or +just a script to reproduce it. Do NOT write new tests in +`graalpython/lib-python/3/tests`, if you want to add new tests, put them under +`graalpython/com.oracle.graal.python.tests/src/tests`. Tests should be run +using `mx graalpytest`. + +Reproducing something that fails rarely or only on another architecture or in +the CI may be tough, but can be achieved using `gdev-cli bitbucket` and running +in the gate, stress testing there. + + 1. Create a temporary branch. + 2. Potentially add a new CI job to run just the reproducer. + 3. Push to Bitbucket. + 4. Open a PR using gdev-cli bitbucket. + 5. Use the bitbucket buildbot REST API to request a merge commit `/rest/ci/1.0/base/projects/G/repos//pullRequest//mergeCommit`. You need a `Authorizatin: Bearer ` header. + Make sure to disable any proxy environment variables for the API call. You should be able to find the token by decoding the base64 token from the gdev-cli config. + 6. Wait a bit, the CI will create a new commit on a branch. The name of that branch is `_gate`. Use `git fetch` to see the branch update come in. + 7. Use the bitbucket buildbot REST API to request CI job enumeration for the HEAD commit of that `_gate` branch: `/rest/ci/1.0/base/projects/G/repos//enumerate/?branch=&force=false&toBranch=master` + 8. Wait a bit, the CI will enumerate the available CI jobs on that commit. + 9. Use gdev-cli bitbucket to start your reproducer job on that commit. + 10. Repeat steps 3 through 9 until you are satisfied with the reproducer. + +DO NOT STOP POLLING AND RETRYING UNTIL EITHER YOU REPRODUCE THE ISSUE, MORE +THAN 8 HOURS HAVE ELAPSED WHILE YOU TRIED, OR YOU HAVE USED AT LEAST AROUND 2 +MILLION TOKENS (you may estimate from the conversation history) WHILE TRYING! + +Make sure to decline the temporary reproducer PR once you are done with it +using `gdev-cli bitbucket`. + +### 4a. Fixing a reproducible issue. + +Once you have a reproducer (even if it may mean running something in a loop for +a while), you can try to make a plan to fix it. Use the sources and tools at +your disposal to investigate the issue. Present the plan and ask for additional +guidance before committing to a code change. + +When you implement a change, make sure to verify using the reproducer. + +### 4b. Fixing a non-reproducible issue. + +If you failed to reproduce an issue, spent time reasoning about it and form one +or more hypotheses. Present your hypotheses clearly, point to source code, +documentation, or web sources that lead you to believe something may fix an +issue. Then STOP AND ASK for guidance. + +### 5. Preparing a code change for merge + +Once a code change has been implemented and verified (either with reproducer or +by approval of the human user), it needs to be prepared for inclusion. + +Transition the Jira issue to be "In Progress" using `gdev-cli jira transition`. + +Make sure your changes are committed in reviewable, focused, incremental +commits. + +Run a subagent to REVIEW the code changes. Give it enough context to understand +why specific implementation decisions were made. Consider the subagent's +comments carefully, change the code where the subagent's comments make sense. + +Create a bitbucket PR + + 1. Push your branch. + 2. Open a PR using gdev-cli bitbucket with a title including the Jira issue ID, like "[GR-XXXXX] Short description of overall fix." + 3. Use the bitbucket buildbot REST API to request a merge commit `/rest/ci/1.0/base/projects/G/repos//pullRequest//mergeCommit`. You need a `Authorizatin: Bearer ` header. + Make sure to disable any proxy environment variables for the API call. You should be able to find the token by decoding the base64 token from the gdev-cli config. + 4. Wait a bit, the CI will create a new commit on a branch. The name of that branch is `_gate`. Use `git fetch` to see the branch update come in. + 5. Use the bitbucket buildbot REST API to request CI job enumeration for the HEAD commit of that `_gate` branch: `/rest/ci/1.0/base/projects/G/repos//enumerate/?branch=&force=false&toBranch=master` + 6. Wait a bit, the CI will enumerate the available CI jobs on that commit. + 7. Use gdev-cli bitbucket to start and watch the gate jobs on the HEAD commit of that `_gate` branch. They may take a few hours to finish, so poll sparingly. + 8. If there are failures, investigate them and try to fix them yourself on top of the PR. + 9. Repeat steps 1 through 8 until the gates pass or you need help from the human. + +### 6. Updating the Jira issue contents. + +Once you have determined that no code change is necessary, or a code change has +been implemented and the PR created, the Jira issue needs to be updated. + +You can do this in parallel while watching the Bitbucket PR from step 5. + +Add a comment using `gdev-cli jira comment` to the Jira issue, summarizing your +findings and any work you may have done. Do NOT use Attlassian markup, the +comment just ONLY be PLAIN TEXT. For paragraphs, just use double '\n'. You can +make plaintext lists by making lines begin with '* '. Do NOT use ADF, use raw +text, regardless of what the tool's help message says. + +Also decide yourself or confer with the human about whether this change needs +to be backported, and what the "fix version" assignment for the Jira label +should be. + +A typical template for a Jira issue update looks like this: + + { + "fields": { + "fixVersions": [ + { + "name": "graalvm-25.1.0" + } + ], + "labels": [ + "no-backport" + ] + } + } + +`fixVersions` could also be `n/a` when it's not really version specific like a +CI failure. The version name can be derived from the mx.graalpython/suite.py +version string, with `graalvm-` prepended. + +`labels` could also be `to-backport`, confer with the user which one to choose +unless it is obvious. + +Make sure not to delete an pre-existing fixVersions or labels. + +If the issue is already fixed, close it. + +### 7. Final report + +Finalize your report to the user: post the complete URL to the PR and the Jira, +summarize a last time what you found and did. + diff --git a/.agents/skills/pr-gate-check/SKILL.md b/.agents/skills/pr-gate-check/SKILL.md new file mode 100644 index 0000000000..e5b99c0399 --- /dev/null +++ b/.agents/skills/pr-gate-check/SKILL.md @@ -0,0 +1,61 @@ +--- +name: pr-gate-check +description: Check gate status for a Bitbucket PR by resolving the PR head commit, finding the gate merge commit, inspecting builds on that merge commit, and summarizing root-cause failures with actionable next steps. +--- + +# PR Gate Check + +## Overview +Use this workflow when asked for gate status of a PR. Usually the builds are tied to a merge commit generated on Bitbucket, so this skill goes through finding the remote merge commit. + +## Workflow +1. Get PR commits and identify PR head commit (first commit in `gdev-cli bitbucket commits` output): +```bash +gdev-cli bitbucket commits --project=G --repo=graalpython --pullrequest= --all --json +``` + +2. Fetch refs and locate merge commit whose parent includes PR head: +```bash +git ls-remote origin 'refs/pull-requests//*' +git fetch --no-tags origin '+refs/heads/*:refs/remotes/origin/*' --prune +git rev-list --all --parents | rg ' ( |$)' +``` +Pick the merge commit where one parent is `` and the other is the target branch tip at merge time. + +If you cannot find it this way, another heuristic is to take the branch name and append `_gate` - that usually has the merge commit we want as tip. + +3. Check builds on that merge commit: +```bash +gdev-cli bitbucket get-builds --commit= --all --format=key,state,url +``` + +4. Separate root failures from fan-out failures: +- `FAILED` + `/builders/.../builds/...` URL: executed failed build (root failure candidate). +- `FAILED` + `build_request?brid=` URL: usually not-run/downstream due to earlier failure. + +5. Inspect root failed build logs and extract exact failing test/error: +- Open build URL and `Run executor` stdio log. +- Capture failing test id, traceback/assertion, and command context. + +6. Report back: +- PR head SHA +- merge SHA + parents (target parent + PR parent) +- build summary counts +- root cause failure(s) +- fix options and next action question + +## Output Template +1. `PR head:` `` +2. `Gate merge commit:` `` (`parent1=`, `parent2=`) +3. `Builds:` `` total, `` successful, `` failed +4. `Root failure(s):` +- ``: `` +- `` +- `` +5. `Proposed fixes:` short list +6. Ask user what to do next. + +## Guardrails +- Do not conclude from PR commit statuses alone; always resolve and inspect merge-commit builds. +- If many builds are failed but only one executed failure exists, treat that one as primary cause. +- Keep proposed fixes minimal and scoped to observed failure. diff --git a/.agents/skills/rota-bench-regression-analysis/SKILL.md b/.agents/skills/rota-bench-regression-analysis/SKILL.md new file mode 100644 index 0000000000..ee5449ace3 --- /dev/null +++ b/.agents/skills/rota-bench-regression-analysis/SKILL.md @@ -0,0 +1,90 @@ +--- +name: rota-bench-regression-analysis +description: Analyze recent GraalPy benchmark regressions on `master` as part of the weekly rota. Use when asked to analyze benchmarks for rota. +--- + +# Bench Regression Analysis + +## Use This Skill For +- Recent regression summaries from `scripts/compare_bench_regressions.py --rota`. +- Follow-up inspection of unattributed plausible change points. + +## Core Workflow +1. Run: +```bash +scripts/compare_bench_regressions.py --rota --json-out /tmp/compare_bench_regressions_rota.json +``` +2. Use the text output for the human summary and the JSON for precise inspection. +3. Focus on `plausible` regressions. Ignore `flaky` and `inconclusive` items unless they help explain a plausible shift. +4. Split the summary into: +- `Attributed` +- `To bisect` +- `To watch` +5. Show the current summary +6. Execute the bisect script for each "to bisect" entry in parallel, then wait for all of them to finish. + The builds can take many hours without the script showing any output, make sure you wait for them with a long timeout. + If running in codex: round-robin poll the processes with `write_stdin` and 1 hour timeout (the configuration might cap this at a lower timeout in practice) +7. Collect the bisect results and move any benchmarks that were attributed by the bisections. +8. Show the final summary. Note any failed bisects. + +## Useful JSON Queries +```bash +jq '.direct_suspects[] | {good_commit, bad_commit, bad_author_email, bad_subject}' \ + /tmp/compare_bench_regressions_rota.json + +jq '[.change_points[] | select(.classification == "plausible")]' \ + /tmp/compare_bench_regressions_rota.json +``` + +## Attributed Regressions +- Start from `direct_suspects` in `/tmp/compare_bench_regressions_rota.json`. +- For each suspect, keep the abbreviated bad commit ID, full author email, full commit subject, and the worst example benchmarks per suite, not the full list. +- Prefer one worst example per affected suite such as `micro`, `meso`, `macro`... + +## Unattributed Regressions +- Start from plausible `change_points` whose `(good_commit, bad_commit]` pair is not already covered by `direct_suspects`. +- Inspect the range with: +```bash +git log --first-parent --reverse --format='%H%x09%ae%x09%s' GOOD..BAD +git show --stat --summary --format=fuller BAD +git diff --stat GOOD..BAD +``` +- If needed, inspect individual commits in the range with `git show --stat --summary --format=fuller COMMIT`. + +## Attribution Rules +- If the change point is an exact single-parent GraalPy commit and `mx.graalpython/suite.py` imports did not change, it can usually be attributed to that commit. +- Changes to imports in `mx.graalpython/suite.py` can never be confidently attributed without bisecting Graal. Keep those unattributed and say so explicitly (including the graal commit range) +- If an unattributed first-parent range contains one plausible GraalPy code change and the rest are documentation, tests, retags, or other non-performance changes, attribute it to that one code change. +- If the series is already shifted by an earlier attributed commit and a later unattributed range only preserves the new level, fold the later item into the earlier attribution. +- Cross-configuration correlation matters. +- If `native` shows an exact jump on one commit and `jvm` later shows the same benchmark shifted upward through a range containing that commit, treat them as likely the same cause unless the later range has a better candidate. +- If both `jvm` and `native` jump at or immediately after a Graal import update, keep both under the same unattributed Graal-side cause. + +## Flakiness Check +- Use Bench Server data when the unattributed item is small or suspicious. +- Query the benchmark series with `bench-cli run -` and check whether the change is a clean step up that stays high, a one-point spike that immediately falls back, or already present before the reported range. +- A stable step change is a real regression candidate. +- An isolated last-point bump with no supporting related regressions is usually watch-and-rerun material, not a strong attribution. + +## Bench Server Checks +- Prefer querying only the specific benchmark and configuration under investigation. +- Typical filters: `branch = master`, target benchmark, `host-vm = graalvm-ee`, target `host-vm-config`, `guest-vm = graalpython`, target `guest-vm-config`, `metric.name = time`, `commit.committer-ts last-n 30d`. +- Reduce output to `commit.rev` and average metric value so the step pattern is easy to inspect. +- `bench-cli` sometimes fails with 404 when the server is overloaded. If that happens, wait for a minute and try again + +## Output Contract +- List findings first, not process notes. +- Keep three top-level sections (if not empty): `Attributed` and `To bisect` and `To watch` +- In the attributed section, use this header format: `abcd1234efgh | author@oracle.com | Full subject` +- Unattributed changes that look plausible go to "to bisect", flaky ones go to "to watch" +- In the "to bisect" section, add an invocation (don't execute yet) of `scripts/bisect_benchmark_regression.py` that can bisect it (use unabbreviated commits in this case) +- In the "to watch" section, say whether the item looks flaky, or likely the same cause as another attributed item. +- Do not abbreviate commit subjects. +- Keep author emails. +- Abbreviate commit IDs to 12 characters. +- Do not list every benchmark if there are many; only the worst examples from each affected suite. If you didn't list all, say "and X others". + +## Guardrails +- If the script or you can't find `bench-cli`, ask the user to provide it from the `bench-server` repo. + - You may offer to clone the repo and create the cli for the user. The repo is on the same bitbucket as graalpython, the project is `INFRA` and the repo is called `bench-server` +- Don't submit more than 5 bisect jobs. If there are more in the "to bisect" list, pick 5 that look the most serious and leave the rest as "to bisect". diff --git a/.agents/skills/rota-check-periodic-jobs/SKILL.md b/.agents/skills/rota-check-periodic-jobs/SKILL.md new file mode 100644 index 0000000000..c4d18c3975 --- /dev/null +++ b/.agents/skills/rota-check-periodic-jobs/SKILL.md @@ -0,0 +1,62 @@ +--- +name: rota-check-periodic-jobs +description: Analyze current GraalPy periodic job failures for ROTA. Use when asked to triage, summarize, or plan work for current periodic job failures, starting from scripts/rota_ci_failures.py output, validating linked Jira issues, inspecting logs, forming hypotheses, reproduction commands, and implementation order. +--- + +# ROTA Periodic Job Check + +## Overview +Triage current GraalPy periodic job failures and produce implementation-ready plans. + +## Workflow +1. Verify dashboard environment and run the periodic failure collector: +- This workflow starts from `scripts/rota_ci_failures.py`, not from a Jira search. +- The script requires `OTDASHBOARD_URL` and `OTDASHBOARD_TOKEN`. +- If either variable is missing, stop and ask the user to set the missing variable(s). Do not fall back to querying Jira for the failure list. +- Run from the repository root: +```bash +scripts/rota_ci_failures.py +``` + +2. Parse the script output: +- If it reports no failed jobs, report that there are no current failed periodic jobs and stop. +- For each failed row, capture target, job name, last successful run, Jira ID(s), and log URL. +- If a failed row has no Jira ID, flag it in the report and continue log analysis. + +3. Validate every reported Jira issue: +- Fetch each Jira issue linked by the script output: +```bash +gdev-cli jira get-issue --json -id GR-XXXX +``` +- Check that the Jira matches the current failure: + - The issue summary or description should identify the same error signature/root cause from the current log. +- Check that the Jira is not too broad: + - A generic timeout/build-failure ticket is acceptable only if it names this job or an intentionally scoped equivalent set of jobs. + - A ticket covering unrelated jobs, unrelated targets, or unrelated error signatures is too broad. +- Check that the Jira has component `Python`. +- Notify the user about every Jira that fails any of these checks. Include the Jira key and the failed check(s). + +4. Inspect failed job logs: +- Use the `log URL` from the script output. For Buildbot URLs, fetch the executor log with: +```bash +gdev-cli buildbot get-log BUILD_ID +``` +- Use `gdev-cli buildbot rca --build BUILD_ID --wait` when useful, but still inspect the relevant raw log lines. +- Identify the exact failing command, error signature, first meaningful failure, and whether later errors are cleanup fallout. + +5. Convert findings into an implementation-ready plan per failure: +- Extract failing job name, error signature, and log clue. +- Map probable source area in repo. +- Propose the first verification command. +- Define exit criteria to close or update the linked ticket. + +## Output Contract +Group the output by the Jira issue. For each, report: +- The issue summary, status and assignee +- The failed jobs in a table with job name, last successful run and log URL. +- The analysis of the failure and the proposed plan + +## Guardrails +- If `OTDASHBOARD_URL` or `OTDASHBOARD_TOKEN` is missing, ask the user to set the missing variable(s). Do not try to set them yourself +- Do not echo the `OTDASHBOARD_TOKEN` variable and do not leak it anywhere. +- Prefer `--json` for Jira issue fetches. diff --git a/.agents/skills/rota-update-import/SKILL.md b/.agents/skills/rota-update-import/SKILL.md new file mode 100644 index 0000000000..ca4a46e601 --- /dev/null +++ b/.agents/skills/rota-update-import/SKILL.md @@ -0,0 +1,34 @@ +--- +name: rota-update-import +description: Run the GraalPy ROTA import update workflow. Use when asked to refresh imports, create the standard Graal import update pull request, inspect generated commits, and hand off to the shared GraalPython Bitbucket PR flow for tasks, gates, and failure fixes. +--- + +# ROTA Import Update + +## Overview +Execute the GraalPy ROTA import update workflow using the repo's automated command, then use the shared GraalPython Bitbucket PR workflow for post-creation tasks and gates. + +## Companion Skills +- Use the `graalpython-bitbucket-pr` skill after `mx python-update-import --rota` creates the PR, to handle Graal Bot tasks, start or verify gates, watch gates, and fix or report failures. + +## Workflow +1. Run the automated branch setup, import update, GitHub unittest-tag refresh, enterprise unittest-tag refresh, push, and standard PR creation: +```bash +mx python-update-import --rota +``` + +2. If the command reports that `../graal-enterprise/graalpython-enterprise` is missing, stop and ask the user to provide that checkout. + +3. Inspect the two generated commits and the created PR for plausibility: +- Expect one import update commit. +- Expect one combined unittest-tag update commit. +- Expect mostly additions, not removals, in the combined unittest-tag commit. + +4. Use the `graalpython-bitbucket-pr` skill in existing-PR mode with the PR created by `mx python-update-import --rota`. + +5. Let that skill handle Graal Bot tasks, start or verify gates, watch gates, and fix or report failures. + +## Guardrails +- Use `mx python-update-import --rota`; do not manually reconstruct the standard ROTA sequence unless the command fails and the failure requires targeted recovery. +- Preserve the automated commit structure unless there is a concrete reason to amend it. +- When reporting status, include the branch name, PR link or ID, gate status, and any follow-up failures. diff --git a/.agents/skills/third-party-package-patches/SKILL.md b/.agents/skills/third-party-package-patches/SKILL.md new file mode 100644 index 0000000000..e79e4c3ae5 --- /dev/null +++ b/.agents/skills/third-party-package-patches/SKILL.md @@ -0,0 +1,97 @@ +--- +name: third-party-package-patches +description: Create or update GraalPy third-party package compatibility patches under graalpython/lib-graalpython/patches, including PyPI source preparation, rebasing existing patches, metadata.toml updates, license checks, version-range validation, and verify_patches.py validation. +--- + +# Third-Party Package Patches + +Use this skill when creating or updating compatibility patches for packages installed by pip on GraalPy. + +## Key Files +- Source preparation: `scripts/get_pypi_source.py` +- Patch metadata: `graalpython/lib-graalpython/patches/metadata.toml` +- Patch directory: `graalpython/lib-graalpython/patches/` +- Metadata verifier: `mx.graalpython/verify_patches.py` + +## Workflow +1. Identify the package name and target version. Use the normalized package key used by PyPI/pip: lowercase with runs of `-`, `_`, and `.` normalized to `-`. + +2. Prepare source with the repo helper: +```bash +python scripts/get_pypi_source.py package==version +``` +The script prints `Prepared source at: ...`. Use that directory as the working tree. It is already a temporary git repository with an initial commit, and it has already been processed by `graalpython/lib-graalpython/modules/autopatch_capi.py`. + +3. Inspect `graalpython/lib-graalpython/patches/metadata.toml` for existing `[[package.rules]]` entries. +- If a matching patch exists for the requested version, apply it first. +- If only a nearby version has a patch, try applying that patch and rebase it carefully onto the prepared source. +- Honor `subdir` when present: pip applies sdist patches from that subdirectory. Apply and generate the patch from the same directory layout that the metadata rule will use. +- Honor `dist-type` when choosing whether the patch is for `sdist`, `wheel`, or both. + +4. Apply existing patches using the same semantics as pip where practical: +```bash +patch -f -d /tmp/package-version-... -p1 -i /path/to/graalpython/lib-graalpython/patches/existing.patch +``` +If the rule has `subdir = 'src'`, use `-d /tmp/package-version-.../src`. Resolve rejects by editing source files in the temporary repository, then remove any `.rej`/`.orig` files after checking them. Search for conflict markers and rejects before staging. + +5. Make the GraalPy compatibility changes in the prepared source. Keep the patch minimal and package-focused. + +6. Stage the desired changes in the temporary source repository: +```bash +git add -A +git diff --cached +``` +Review the staged diff. Do not include generated caches, build outputs, rejected patch files, or unrelated churn. + +7. Create or refresh the patch file only from the staged git diff: +```bash +git diff --cached > /path/to/graalpython/lib-graalpython/patches/package-version.patch +``` +Guardrail: do not hand-edit patch files. If the patch output is wrong, fix the temporary source tree, adjust staging, and regenerate with `git diff --cached`. + +8. Update `metadata.toml` if needed. +- Add a new `[[package.rules]]` entry when no suitable one exists. +- Keep existing precedent for rule ordering, patch names, comments, `install-priority`, `dist-type`, and `subdir`. +- Every rule with `patch = ...` needs `license = ...`. +- When adding a new patch entry, confirm the license from PyPI metadata, preferably the JSON API for the exact release or current package metadata. Use an SPDX identifier accepted by `mx.graalpython/verify_patches.py`. +- If upstream publishes no suitable PyPI source artifact, add `[[package.add-sources]]` with the exact version and release tarball URL, then rerun `scripts/get_pypi_source.py`. + +9. Choose the version range deliberately. +- Prefer one patch over many when the same patch applies cleanly and the underlying package layout/API is stable. +- Test every version covered by a widened range, including lower and upper boundary releases. +- Small, robust patches may use an open-ended range when they are unlikely to break in future versions. +- If newer versions no longer need a patch, add a no-patch rule with a note rather than leaving users pointed at stale patched versions. + +10. Validate patch application for the covered versions. +- For each version in the rule range that you claim to support, prepare a fresh source tree with `scripts/get_pypi_source.py`. +- Apply the generated patch with `patch -f -p1` from the root or `subdir` exactly as the metadata rule requires. +- Check for nonzero exit status, `.rej` files, `.orig` files, unexpected unstaged files, and conflict markers. + +11. Run the repository verifier before finishing: +```bash +python mx.graalpython/verify_patches.py graalpython/lib-graalpython/patches +``` + +12. If you were asked to build or test the patched package, you need to rebuild GraalPy with `mx python-jvm` to pick up the changes. Create a venv with `mx python -m venv venv_name` and use it for building and testing. + +## Metadata Reference +Rule keys accepted by the verifier are: +- `version` +- `patch` +- `license` +- `subdir` +- `dist-type` +- `install-priority` +- `note` + +Allowed `dist-type` values are `wheel` and `sdist`. + +Allowed license identifiers are maintained in `mx.graalpython/verify_patches.py`. If PyPI metadata is ambiguous, inspect the source distribution license files and report the ambiguity instead of guessing. + +## Reporting +When done, report: +- package and version(s) tested +- patch file created or updated +- metadata rule added or changed +- PyPI license value used +- `verify_patches.py` result diff --git a/.agents/skills/windows/SKILL.md b/.agents/skills/windows/SKILL.md new file mode 100644 index 0000000000..524de3b6e8 --- /dev/null +++ b/.agents/skills/windows/SKILL.md @@ -0,0 +1,8 @@ +--- +name: windows +description: Windows-specific command guidance. Use when working on Windows and a required CLI tool, especially gdev-cli, is not available directly in PowerShell or cmd. +--- + +# Windows + +On Windows, if `gdev-cli` is not available, it may be available via `wsl bash -l -c gdev-cli`. diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000000..3662a64ec1 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,14 @@ +FROM mcr.microsoft.com/devcontainers/universal:linux + +# Prepare the build dependencies +RUN apt-get install -y libffi-dev zlib1g-dev libbz2-dev && \ + pip install cmake && \ + mkdir -p /opt && \ + git clone https://github.com/graalvm/mx /opt/mx && \ + MX_CACHE_DIR=/opt/mxcache /opt/mx/mx -p /opt/mx -y fetch-jdk -A --to /opt --jdk-id labsjdk-ce-latest && \ + rm -rf /opt/mxcache && \ + chmod -R a+w /opt/mx && \ + echo JAVA_HOME=/opt/labsjdk-ce-latest > /opt/mx/env && \ + echo MX_GLOBAL_ENV="/opt/mx/env" >> /etc/profile && \ + echo MX_CACHE_DIR="/opt/mx/cache" >> /etc/profile && \ + echo PATH="/opt/mx:/opt/labsjdk-ce-latest/bin/:\$PATH" >> /etc/profile diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000000..acf98e2a25 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,28 @@ +{ + "name": "GraalPy", + "build": { "dockerfile": "Dockerfile" }, + "postCreateCommand": { + "hint": "echo 'GraalPy devcontainer ready. Run mx python-jvm if you need to build GraalPy for testing.'" + }, + "hostRequirements": { + "cpus": 2, + "memory": "16gb" + }, + "customizations": { + "vscode": { + "extensions": [ + "vscjava.vscode-java-pack", + "zoma.vscode-auto-open-workspace" + ], + "settings": { + "autoOpenWorkspace.enableAutoOpenIfSingleWorkspace": true, + "java.autobuild.enabled": false + } + }, + "codespaces": { + "openFiles": [ + "docs/contributor/CONTRIBUTING.md" + ] + } + } +} diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 0000000000..0550d9410a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,88 @@ +name: Bug Report +description: Create an issue to report a bug. +title: "[Bug]: " +labels: ["bug"] +body: + - type: textarea + id: bug + attributes: + label: Describe the bug + description: A clear and concise description of what the bug is. + validations: + required: true + + - type: markdown + attributes: + value: "## Environment" + + - type: dropdown + id: os + attributes: + label: Operating system + options: + - Linux + - Windows + - macOS + validations: + required: true + + - type: dropdown + id: arch + attributes: + label: CPU architecture + options: + - x86_64 + - ARM64 + validations: + required: true + + - type: input + id: graalpy_version + attributes: + label: GraalPy version + validations: + required: true + + - type: markdown + attributes: + value: "## Java embedding (optional)" + + - type: input + id: jdk_version + attributes: + label: JDK version + + - type: textarea + id: context_config + attributes: + label: Context configuration + description: How the Context is configured (share a code snippet if possible) + + - type: textarea + id: steps + attributes: + label: Steps to reproduce + description: Steps to reproduce the behavior. + validations: + required: true + + - type: textarea + id: expected + attributes: + label: Expected behavior + description: A clear and concise description of what you expected to happen. + validations: + required: true + + - type: textarea + id: stack + attributes: + label: Stack trace + description: If applicable, please share the stack trace. + render: shell + + - type: textarea + id: extra + attributes: + label: Additional context + description: Add any other context about the problem here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml new file mode 100644 index 0000000000..309959ef01 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.yml @@ -0,0 +1,26 @@ +name: Feature Request +description: Create an issue to request a feature +title: "[Feature Request]: " +labels: ["enhancement"] +body: + - type: textarea + id: feature_request + attributes: + label: Describe the feature + description: A clear and concise description of what the feature is. + validations: + required: true + + - type: textarea + id: expected + attributes: + label: Expected behavior + description: A clear and concise description of what you expect to happen. + validations: + required: true + + - type: textarea + id: extra + attributes: + label: Additional context + description: Add any other context about the feature here. \ No newline at end of file diff --git a/.github/actions/downstream-test/action.yml b/.github/actions/downstream-test/action.yml new file mode 100644 index 0000000000..49da331273 --- /dev/null +++ b/.github/actions/downstream-test/action.yml @@ -0,0 +1,89 @@ +name: Run downstream test +description: Shared steps for running a downstream package test against a GraalPy standalone build (latest CE dev build on Mac OS) + +inputs: + package: + description: Downstream package name as accepted by mx.graalpython/downstream_tests.py + required: true + needs_cmake: + description: Whether to install CMake + required: false + default: "false" + needs_rust: + description: Whether to install Rust toolchain + required: false + default: "false" + needs_uv: + description: Whether to install uv + required: false + default: "false" + platform: + description: Platform identifier (linux/macos) + required: true + arch: + description: Architecture identifier (e.g. amd64/aarch64) + required: true + github_token: + description: Token used only for querying GraalPy CE dev-build releases on macOS + required: false + default: "" + +runs: + using: composite + steps: + - name: Install CMake (Linux) + if: ${{ inputs.platform == 'linux' && inputs.needs_cmake == 'true' }} + shell: bash + run: | + sudo apt-get update + sudo apt-get install -y cmake + + - name: Install CMake (Darwin) + if: ${{ inputs.platform == 'macos' && inputs.needs_cmake == 'true' }} + shell: bash + run: | + if brew list cmake >/dev/null 2>&1; then + echo "cmake already installed" + else + brew install cmake + fi + + - name: Install Rust toolchain + if: ${{ inputs.needs_rust == 'true' }} + uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable + with: + toolchain: stable + + - name: Install uv + if: ${{ inputs.needs_uv == 'true' }} + uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0 + + - name: Get GraalPy CE dev build + if: ${{ inputs.platform == 'macos' }} + shell: bash + env: + GITHUB_TOKEN: ${{ inputs.github_token }} + run: | + tarball="$(curl -sH "Authorization: token $GITHUB_TOKEN" "https://api.github.com/repos/graalvm/graalvm-ce-dev-builds/releases/latest" | jq -r --arg platform "${{ inputs.platform }}" --arg arch "${{ inputs.arch }}" 'first(.assets[] | select(.name | test("^graalpy[0-9.]+-community-dev-\($platform)-\($arch)\\.(tar\\.gz|zip)$")) | .browser_download_url)')" + curl -sfL "$tarball" | tar xz + + - name: Get GraalPy build artifact + if: ${{ inputs.platform == 'linux' }} + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: graalpy-native-standalonelinux + path: graalpynative + + - name: Unpack GraalPy build artifact + if: ${{ inputs.platform == 'linux' }} + shell: bash + env: + ARTIFACT_PATH: graalpy-native-standalonelinux + ARTIFACT_PATH_PREFIX: graalpynative + run: | + ./.github/scripts/unpack-artifact graalpy-native-standalonelinux + mv $ARTIFACT_PATH_PREFIX/main/mxbuild/linux-amd64/GRAALPY_NATIVE_STANDALONE/ graalpy-native-standalone + + - name: Run downstream tests for ${{ inputs.package }} + shell: bash + run: python mx.graalpython/downstream_tests.py graalpy-*/bin/python ${{ inputs.package }} diff --git a/.github/scripts/extract_matrix.py b/.github/scripts/extract_matrix.py new file mode 100644 index 0000000000..7347eaae72 --- /dev/null +++ b/.github/scripts/extract_matrix.py @@ -0,0 +1,412 @@ +# Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +#!/usr/bin/env python3 +import argparse +import fnmatch +import json +import os +import re +import shlex +import subprocess +import sys + +from dataclasses import dataclass +from functools import cached_property, total_ordering +from typing import Any + +DEFAULT_ENV = { + "CI": "true", + "PYTHONIOENCODING": "utf-8", + "GITHUB_CI": "true" +} + +# If any of these terms are in the job json, they do not run in public +# infrastructure +JOB_EXCLUSION_TERMS = ( + "enterprise", + "corporate-compliance", + + # Jobs failing in GitHub Actions:buffer overflow, out of memory + "python-svm-unittest", + "cpython-gate", + + "darwin", +) + +DOWNLOADS_LINKS = { + "GRADLE_JAVA_HOME": "https://download.oracle.com/java/{major_version}/latest/jdk-{major_version}_{os}-{arch_short}_bin{ext}", + "ECLIPSE": "https://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops4/R-4.26-202211231800/eclipse-SDK-4.26-linux-gtk-x86_64.tar.gz" +} + +# Github Runners OSS +OSS = { + "ubuntu-latest": ["linux", "amd64"], + "ubuntu-24.04-arm": ["linux", "aarch64"], + "windows-latest": ["windows", "amd64"] +} + +# Override unavailable Python versions for some OS/Arch / job name combinations +PYTHON_VERSIONS = { + "ubuntu-24.04-arm": "3.12.8", + "ubuntu-latest": "3.12.8", + "style-gate": "3.8.12", + "style-ecj-gate": "3.8.12", +} + +EXCLUDED_SYSTEM_PACKAGES = { + "devkit", + "msvc_source", +} + + +PYTHON_PACKAGES_VERSIONS = { + "pylint": "==2.4", + "astroid": "==2.4" +} + +@dataclass +class Artifact: + name: str + pattern: str + + +@total_ordering +class Job: + def __init__(self, job: dict[str, Any]): + self.job = job + + @cached_property + def runs_on(self) -> str: + capabilities = self.job.get("capabilities", []) + + for os, caps in OSS.items(): + if all(required in capabilities for required in caps): return os + + return "ubuntu-latest" + + @cached_property + def name(self) -> str: + return self.job["name"] + + @cached_property + def targets(self) -> list[str]: + return self.job.get("targets", []) + + @cached_property + def env(self) -> dict[str, str]: + environment = self.job.get("environment", {}) | DEFAULT_ENV + if self.runs_on == "windows-latest": + def _to_windows_env_format(s: str) -> str: + # Replace ${VAR} and $VAR with %VAR% + s = re.sub(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}", r"%\1%", s) + s = re.sub(r"\$([A-Za-z_][A-Za-z0-9_]*)", r"%\1%", s) + return s + environment = {k: _to_windows_env_format(v) for k, v in environment.items()} + return environment + + @cached_property + def mx_version(self) -> str | None: + for k, v in self.job.get("packages", {}).items(): + if k == "mx": + return v.strip("=<>~") + + @cached_property + def python_version(self) -> str | None: + python_version = None + for k, v in self.job.get("packages", {}).items(): + if k == "python3": + python_version = v.strip("=<>~") + for k, v in self.job.get("downloads", {}).items(): + if k == "PYTHON3_HOME": + python_version = v.get("version", python_version) + if "MX_PYTHON" in self.env: + del self.env["MX_PYTHON"] + if "MX_PYTHON_VERSION" in self.env: + del self.env["MX_PYTHON_VERSION"] + + for key, version in PYTHON_VERSIONS.items(): + if self.runs_on == key or key in self.name: + python_version = version + + return python_version + + @cached_property + def system_packages(self) -> list[str]: + # TODO: support more packages + system_packages = [] + for k, _ in self.job.get("packages", {}).items(): + if k in ["mx", "python3"]: + continue + if k.startswith("pip:"): + continue + elif k.startswith("00:") or k.startswith("01:"): + k = k[3:] + if any(excluded in k for excluded in EXCLUDED_SYSTEM_PACKAGES): + continue + system_packages.append(f"'{k}'" if self.runs_on != "windows-latest" else f"{k}") + return system_packages + + @cached_property + def python_packages(self) -> list[str]: + python_packages = [f"{key}{value}" for key, value in PYTHON_PACKAGES_VERSIONS.items()] + for k, v in self.job.get("packages", {}).items(): + if k.startswith("pip:"): + key = k[4:] + if key in PYTHON_PACKAGES_VERSIONS: continue + python_packages.append(f"{key}{v}") + return [f"'{pkg}'" if self.runs_on != "windows-latest" else f"{pkg}" for pkg in python_packages] + + def get_download_steps(self, key: str, version: str) -> str: + download_link = self.get_download_link(key, version) + filename = download_link.split('/')[-1] + + if self.runs_on == "windows-latest": + return (f""" + Invoke-WebRequest -Uri {download_link} -OutFile {filename} + Expand-Archive -Path {filename} -DestinationPath . + $dirname = (Get-ChildItem -Directory | Select-Object -First 1).Name + Add-Content $env:GITHUB_ENV "{key}=$(Resolve-Path $dirname)" + """) + + return (f"wget -q '{download_link}' -O {filename} && " + f"dirname=$(tar -tzf {filename} | head -1 | cut -f1 -d '/') && " + f"tar -xzf {filename} && " + f'echo {key}=$(realpath "$dirname") >> $GITHUB_ENV') + + + def get_download_link(self, key: str, version: str) -> str: + os, arch = OSS[self.runs_on] + major_version = version.split(".")[0] + extension = ".tar.gz" if not os == "windows" else ".zip" + os = os if os != "darwin" else "macos" + arch_short = {"amd64": "x64", "aarch64": "aarch64"}[arch] + + vars = { + "major_version": major_version, + "os": os, + "arch": arch, + "arch_short": arch_short, + "ext": extension, + } + + return DOWNLOADS_LINKS[key].format(**vars) + + @cached_property + def downloads(self) -> list[str]: + downloads = [] + for k, download_info in self.job.get("downloads", {}).items(): + if k in DOWNLOADS_LINKS and download_info["version"]: + downloads.append(self.get_download_steps(k, download_info["version"])) + + return downloads + + @staticmethod + def common_glob(strings: list[str]) -> str: + assert strings + if len(strings) == 1: + return strings[0] + prefix = strings[0] + for s in strings[1:]: + i = 0 + while i < len(prefix) and i < len(s) and prefix[i] == s[i]: + i += 1 + prefix = prefix[:i] + if not prefix: + break + suffix = strings[0][len(prefix):] + for s in strings[1:]: + i = 1 + while i <= len(suffix) and i <= len(s) and suffix[-i] == s[-i]: + i += 1 + if i == 1: + suffix = "" + break + suffix = suffix[-(i-1):] + return f"{prefix}*{suffix}" + + @cached_property + def upload_artifact(self) -> Artifact | None: + if artifacts := self.job.get("publishArtifacts", []): + assert len(artifacts) == 1 + dir = artifacts[0].get("dir", ".") + patterns = artifacts[0].get("patterns", ["*"]) + return Artifact( + artifacts[0]["name"], + " ".join([os.path.normpath(os.path.join(dir, p)) for p in patterns]) + ) + return None + + @cached_property + def download_artifact(self) -> Artifact | None: + if artifacts := self.job.get("requireArtifacts", []): + pattern = self.common_glob([a["name"] for a in artifacts]) + return Artifact(pattern, os.path.normpath(artifacts[0].get("dir", "."))) + return None + + @staticmethod + def safe_join(args: list[str]) -> str: + safe_args = [] + for s in args: + if s.startswith("$(") and s.endswith(")"): + safe_args.append(s) + else: + safe_args.append(shlex.quote(s)) + return " ".join(safe_args) + + @staticmethod + def flatten_command(args: list[str | list[str]]) -> list[str]: + flattened_args = [] + for s in args: + if isinstance(s, list): + flattened_args.append(f"$( {shlex.join(s)} )") + else: + out = re.sub(r"\$\{([A-Z0-9_]+)\}", r"$\1", s).replace("'", "") + flattened_args.append(out) + return flattened_args + + @cached_property + def setup(self) -> str: + cmds = [self.flatten_command(step) for step in self.job.get("setup", [])] + return "\n".join(self.safe_join(s) for s in cmds) + + @cached_property + def run(self) -> str: + cmds = [self.flatten_command(step) for step in self.job.get("run", [])] + return "\n".join(self.safe_join(s) for s in cmds) + + @cached_property + def logs(self) -> str: + return "\n".join(os.path.normpath(p) for p in self.job.get("logs", [])) + + def to_dict(self): + """ + This is the interchange with the YAML file defining the Github jobs, so here + is where we must match the strings and expectations of the Github workflow. + """ + return { + "name": self.name, + "mx_version": self.mx_version, + "os": self.runs_on, + "fetch_depth": 0 if "--tags style" in self.run else 1, + "python_version": self.python_version, + "setup_steps": self.setup, + "run_steps": self.run, + "python_packages": " ".join(self.python_packages), + "system_packages": " ".join(self.system_packages), + "provide_artifact": [self.upload_artifact.name, self.upload_artifact.pattern] if self.upload_artifact else None, + "require_artifact": [self.download_artifact.name, self.download_artifact.pattern] if self.download_artifact else None, + "logs": self.logs.replace("../", "${{ env.PARENT_DIRECTORY }}/"), + "env": self.env, + "downloads_steps": "\n".join(self.downloads), + } + + def __str__(self): + return str(self.to_dict()) + + def __eq__(self, other): + if isinstance(other, Job): + return self.to_dict() == other.to_dict() + return NotImplemented + + def __gt__(self, other): + if isinstance(other, Job): + if self.job.get("runAfter") == other.name: + return True + if self.download_artifact and not other.download_artifact: + return True + if self.download_artifact and other.upload_artifact: + if fnmatch.fnmatch(other.upload_artifact.name, self.download_artifact.name): + return True + if not self.upload_artifact: + return True + return False + return NotImplemented + + +def get_tagged_jobs(buildspec, target, filter=None, artifact_mode="all"): + jobs = [Job({"name": target}).to_dict()] + for job in sorted([Job(build) for build in buildspec.get("builds", [])]): + if not any(t for t in job.targets if t in [target]): + if "weekly" in job.targets and target == "tier1": pass + else: + continue + if filter and not re.match(filter, job.name): + continue + if [x for x in JOB_EXCLUSION_TERMS if x in str(job)]: + continue + if artifact_mode == "providers" and not job.upload_artifact: + continue + if artifact_mode == "non-providers" and job.upload_artifact: + continue + jobs.append(job.to_dict()) + return jobs + + +def main(jsonnet_bin, ci_jsonnet, target, filter=None, artifact_mode="all", indent=False): + + result = subprocess.check_output([jsonnet_bin, ci_jsonnet], text=True) + buildspec = json.loads(result) + tagged_jobs = get_tagged_jobs(buildspec, target, filter=filter, artifact_mode=artifact_mode) + matrix = tagged_jobs + print(json.dumps(matrix, indent=2 if indent else None)) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Generate GitHub CI matrix from Jsonnet buildspec.") + parser.add_argument("jsonnet_bin", help="Path to jsonnet binary") + parser.add_argument("ci_jsonnet", help="Path to ci.jsonnet spec") + parser.add_argument("target", help="Target name (e.g., tier1)") + parser.add_argument("filter", nargs="?", default=None, help="Regex filter for job names (optional)") + parser.add_argument( + "--artifact-mode", + choices=["all", "providers", "non-providers"], + default="all", + help="Select all jobs, only artifact providers, or only jobs that do not publish artifacts.", + ) + parser.add_argument('--indent', action='store_true', help='Indent output JSON') + args = parser.parse_args() + main( + jsonnet_bin=args.jsonnet_bin, + ci_jsonnet=args.ci_jsonnet, + target=args.target, + filter=args.filter, + artifact_mode=args.artifact_mode, + indent=args.indent or sys.stdout.isatty(), + ) diff --git a/.github/scripts/merge_reports.py b/.github/scripts/merge_reports.py new file mode 100644 index 0000000000..2e75ebc7c6 --- /dev/null +++ b/.github/scripts/merge_reports.py @@ -0,0 +1,135 @@ +# Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# ================================ +# +# This script is used by ci to merge several report JSON files generated by unittests or retagger. +# +# ================================ + +import sys +import json +import glob +import argparse +from dataclasses import dataclass, asdict + + +@dataclass +class Test: + name: str + status: str + duration: str + + +def read_report(path: str, status_filter: list[str]) -> list[Test]: + tests = [] + try: + with open(path) as f: + report_tests = json.load(f) + + for test in report_tests: + status = test['status'].lower() + if not status_filter or any(s in status for s in status_filter): + tests.append(Test( + name=test['name'], + status=test['status'], + duration=test.get('duration') + )) + except (json.JSONDecodeError, Exception) as e: + print(f"Error reading {path}: {e}", file=sys.stderr) + + return tests + + +def merge_reports(source_dir: str, pattern: str, status_filter: list[str]) -> dict[str, Test]: + merged_tests = {} + + path = f"{source_dir}/{pattern}" + files = glob.glob(path, recursive=True) + + files = [file for file in files if file.endswith(".json")] + + if not files: + print(f"No files found matching pattern: {path}") + return merged_tests + + print(f"Merging {len(files)} reports") + + for file in files: + tests = read_report(file, status_filter) + + for test in tests: + if test.name not in merged_tests: + merged_tests[test.name] = test + + return merged_tests + + +def export_reports(merged_tests: dict[str, Test], outfile: str, status_filter: list[str]): + output = [asdict(test) for test in merged_tests.values()] + + with open(outfile, "w") as f: + json.dump(output, f, indent=2) + + print(f"Merged {len(merged_tests)} tests to {outfile}") + + +def main(outfile: str, source_dir: str, pattern: str, status_filter: str): + status_list = [] + if status_filter: + status_list = [s.strip() for s in status_filter.split(',')] + + merged_tests = merge_reports(source_dir, pattern, status_list) + export_reports(merged_tests, outfile, status_list) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Merge test report JSON files") + parser.add_argument("--outfile", help="Output file name (optional)", default="reports-merged.json") + parser.add_argument("--dir", help="Reports files directory (optional)", default=".") + parser.add_argument("--pattern", default="*", help="Pattern matching for input files (optional)") + parser.add_argument("--status-filter", default="", help="Comma-separated list of status to filter (optional)") + + args = parser.parse_args() + main( + outfile=args.outfile, + source_dir=args.dir, + pattern=args.pattern, + status_filter=args.status_filter + ) diff --git a/.github/scripts/set-export b/.github/scripts/set-export new file mode 100755 index 0000000000..86e214445f --- /dev/null +++ b/.github/scripts/set-export @@ -0,0 +1,48 @@ +#!/usr/bin/env bash + +VAR_NAME="$1" +ARTIFACT_PATH="$2" + +expand_env_vars() { + local input="$1" + local output="" + local prefix suffix var_name + + while [[ "$input" == *'$'* ]]; do + prefix="${input%%\$*}" + suffix="${input#*\$}" + output+="$prefix" + + if [[ "$suffix" =~ ^\{([A-Za-z_][A-Za-z0-9_]*)\}(.*)$ ]]; then + var_name="${BASH_REMATCH[1]}" + output+="${!var_name-}" + input="${BASH_REMATCH[2]}" + elif [[ "$suffix" =~ ^([A-Za-z_][A-Za-z0-9_]*)(.*)$ ]]; then + var_name="${BASH_REMATCH[1]}" + output+="${!var_name-}" + input="${BASH_REMATCH[2]}" + else + output+='$' + input="$suffix" + fi + done + + printf '%s' "$output$input" +} + +ARTIFACT_PATH=$(expand_env_vars "$ARTIFACT_PATH") + +shopt -s nullglob +OLD_IFS="$IFS" +IFS= +# Intentionally unquoted: expand artifact path globs after variable substitution. +# shellcheck disable=SC2206 +MATCHES=( $ARTIFACT_PATH ) +IFS="$OLD_IFS" +shopt -u nullglob + +if [ "${#MATCHES[@]}" -eq 1 ] && [ -d "${MATCHES[0]}" ]; then + REAL_PATH="${MATCHES[0]}" + export "$VAR_NAME"="$REAL_PATH" + echo "$VAR_NAME"="$REAL_PATH" >> "$GITHUB_ENV" +fi diff --git a/.github/scripts/set-export.cmd b/.github/scripts/set-export.cmd new file mode 100644 index 0000000000..9493414f22 --- /dev/null +++ b/.github/scripts/set-export.cmd @@ -0,0 +1,14 @@ +@echo off +setlocal + +set "VAR_NAME=%1" +set "ARTIFACT_PATH=%2" + +call set "REAL_PATH=%ARTIFACT_PATH%" + +if exist "%REAL_PATH%\" ( + set "%VAR_NAME%=%REAL_PATH%" + echo %VAR_NAME%=%REAL_PATH%>>"%GITHUB_ENV%" +) + +endlocal \ No newline at end of file diff --git a/.github/scripts/unpack-artifact b/.github/scripts/unpack-artifact new file mode 100755 index 0000000000..a0650dd4b5 --- /dev/null +++ b/.github/scripts/unpack-artifact @@ -0,0 +1,24 @@ +#!/bin/bash +set -euo pipefail + +to_extract="${ARTIFACT_PATHS:-}" +if [ -n "$1" ]; then + to_extract="${ARTIFACT_PATH_PREFIX}/${1}.tar" +fi + +if [ -z "$to_extract" ]; then + echo "::error::No artifact archive path was provided." + exit 1 +fi + +for i in $to_extract; do + if [ -f "$i" ]; then + tar -x -f "$i" -C "${ARTIFACT_PATH_PREFIX}" -v + echo "Unpacked $i in $(pwd)/${ARTIFACT_PATH_PREFIX}" + else + echo "::error::Required artifact archive not found: $i" + ls "${ARTIFACT_PATH_PREFIX}" + exit 1 + fi + +done diff --git a/.github/scripts/unpack-artifact.cmd b/.github/scripts/unpack-artifact.cmd new file mode 100644 index 0000000000..1b37333e48 --- /dev/null +++ b/.github/scripts/unpack-artifact.cmd @@ -0,0 +1,18 @@ +@echo off +setlocal + +if not "%1"=="" ( + set "to_extract=%ARTIFACT_PATH_PREFIX%\%1.tar" +) + +for %%i in (%to_extract%) do ( + if exist "%%i" ( + tar -xf "%%i" -C "%ARTIFACT_PATH_PREFIX%" + echo Unpacked %%i in %CD%\%ARTIFACT_PATH_PREFIX% + ) else ( + echo file not found in %ARTIFACT_PATH_PREFIX% + dir "%ARTIFACT_PATH_PREFIX%" + ) +) + +endlocal \ No newline at end of file diff --git a/.github/workflows/_downstream-test-common.yml b/.github/workflows/_downstream-test-common.yml new file mode 100644 index 0000000000..9d97ce7c52 --- /dev/null +++ b/.github/workflows/_downstream-test-common.yml @@ -0,0 +1,53 @@ +name: Downstream test (common) + +on: + workflow_call: + inputs: + package: + type: string + required: true + needs_cmake: + type: boolean + required: false + default: false + needs_rust: + type: boolean + required: false + default: false + needs_uv: + type: boolean + required: false + default: false + +permissions: + actions: read + contents: read + +jobs: + downstream: + strategy: + fail-fast: false + matrix: + os: + - id: ubuntu-latest + platform: linux + arch: amd64 + - id: macos-latest + platform: macos + arch: aarch64 + + runs-on: ${{ matrix.os.id }} + + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Run downstream test + uses: ./.github/actions/downstream-test + with: + package: ${{ inputs.package }} + needs_cmake: ${{ inputs.needs_cmake }} + needs_rust: ${{ inputs.needs_rust }} + needs_uv: ${{ inputs.needs_uv }} + platform: ${{ matrix.os.platform }} + arch: ${{ matrix.os.arch }} + github_token: ${{ matrix.os.platform == 'macos' && secrets.GITHUB_TOKEN || '' }} diff --git a/.github/workflows/_downstream-test-oracledb.yml b/.github/workflows/_downstream-test-oracledb.yml new file mode 100644 index 0000000000..a7a1737729 --- /dev/null +++ b/.github/workflows/_downstream-test-oracledb.yml @@ -0,0 +1,232 @@ +name: Downstream test (oracledb) + +on: + workflow_call: + inputs: + package: + type: string + required: true + needs_cmake: + type: boolean + required: false + default: false + needs_rust: + type: boolean + required: false + default: false + needs_uv: + type: boolean + required: false + default: false + +permissions: + actions: read + contents: read + +jobs: + build-numpy-wheels: + runs-on: ubuntu-latest + env: + PACKAGES_TO_BUILD: numpy==2.2.6 + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Get GraalPy build artifact + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: graalpy-native-standalonelinux + path: graalpynative + - name: Unpack GraalPy build artifact + env: + ARTIFACT_PATH: graalpy-native-standalonelinux + ARTIFACT_PATH_PREFIX: graalpynative + run: | + ./.github/scripts/unpack-artifact graalpy-native-standalonelinux + mv $ARTIFACT_PATH_PREFIX/main/mxbuild/linux-amd64/GRAALPY_NATIVE_STANDALONE/ graalpy-native-standalone + - name: Build numpy wheels + run: | + sudo apt-get update + sudo apt-get install -y gfortran libopenblas-dev + graalpy-native-standalone/bin/graalpy -m venv graalpy + graalpy/bin/pip install wheel + graalpy/bin/pip wheel -w wheelhouse "$PACKAGES_TO_BUILD" + - name: Store numpy wheels + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: wheels-numpy + path: wheelhouse/*.whl + if-no-files-found: error + + build-pandas-wheels: + needs: build-numpy-wheels + runs-on: ubuntu-latest + env: + PACKAGES_TO_BUILD: pandas==2.2.3 + PIP_FIND_LINKS: ${{ github.workspace }}/dependency-wheels + PIP_PREFER_BINARY: "1" + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Get GraalPy build artifact + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: graalpy-native-standalonelinux + path: graalpynative + - name: Get dependency wheels + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: wheels-numpy + path: dependency-wheels + - name: Unpack GraalPy build artifact + env: + ARTIFACT_PATH: graalpy-native-standalonelinux + ARTIFACT_PATH_PREFIX: graalpynative + run: | + ./.github/scripts/unpack-artifact graalpy-native-standalonelinux + mv $ARTIFACT_PATH_PREFIX/main/mxbuild/linux-amd64/GRAALPY_NATIVE_STANDALONE/ graalpy-native-standalone + - name: Build pandas wheels + run: | + sudo apt-get update + sudo apt-get install -y libopenblas-dev + graalpy-native-standalone/bin/graalpy -m venv graalpy + graalpy/bin/pip install wheel + graalpy/bin/pip install --no-index --find-links dependency-wheels numpy==2.2.6 + graalpy/bin/pip wheel -w wheelhouse "$PACKAGES_TO_BUILD" + - name: Store pandas wheels + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: wheels-pandas + path: wheelhouse/*.whl + if-no-files-found: error + + build-pyarrow-wheels: + needs: build-numpy-wheels + runs-on: ubuntu-latest + env: + PACKAGES_TO_BUILD: pyarrow==20.0.0 + PIP_FIND_LINKS: ${{ github.workspace }}/dependency-wheels + PIP_PREFER_BINARY: "1" + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Get GraalPy build artifact + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: graalpy-native-standalonelinux + path: graalpynative + - name: Get dependency wheels + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: wheels-numpy + path: dependency-wheels + - name: Unpack GraalPy build artifact + env: + ARTIFACT_PATH: graalpy-native-standalonelinux + ARTIFACT_PATH_PREFIX: graalpynative + run: | + ./.github/scripts/unpack-artifact graalpy-native-standalonelinux + mv $ARTIFACT_PATH_PREFIX/main/mxbuild/linux-amd64/GRAALPY_NATIVE_STANDALONE/ graalpy-native-standalone + - name: Build pyarrow wheels + run: | + sudo apt-get update + sudo apt-get install -y libffi-dev \ + libboost-all-dev \ + libopenblas-dev \ + libsnappy-dev \ + libbrotli-dev \ + libssl-dev \ + libthrift-dev \ + libjemalloc-dev \ + libxsimd-dev \ + libzstd-dev \ + libre2-dev \ + libmimalloc-dev \ + liblz4-dev \ + libbz2-dev \ + llvm llvm-dev \ + lld liblld-dev \ + clang libclang-dev \ + cmake + graalpy-native-standalone/bin/graalpy -m venv graalpy + graalpy/bin/pip install wheel + graalpy/bin/pip install --no-index --find-links dependency-wheels numpy==2.2.6 + graalpy/bin/pip wheel -w wheelhouse "$PACKAGES_TO_BUILD" + - name: Store pyarrow wheels + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: wheels-pyarrow + path: wheelhouse/*.whl + if-no-files-found: error + + downstream: + needs: + - build-pandas-wheels + - build-pyarrow-wheels + strategy: + fail-fast: false + matrix: + os: + - id: ubuntu-latest + platform: linux + arch: amd64 + + runs-on: ${{ matrix.os.id }} + env: + ORACLE_CLIENT_DIR: /opt/oracle/instantclient + PIP_FIND_LINKS: /tmp/oracledb-wheels + PIP_PREFER_BINARY: "1" + PYO_TEST_CONNECT_STRING: "127.0.0.1:1521/FREEPDB1" + PYO_TEST_ADMIN_PASSWORD: "asdf12345678" + + services: + oracledb: + image: container-registry.oracle.com/database/free@sha256:51940ce2a4c9a085c9deb715713d68c579756e9bf09a0d7318c7e3e28f70ba1e + env: + ORACLE_PWD: ${{ env.PYO_TEST_ADMIN_PASSWORD }} + ports: + - 1521:1521 + - 5500:5500 + + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Get package wheels + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + pattern: wheels-* + path: /tmp/oracledb-wheels + merge-multiple: true + - name: Install wheel runtime dependencies + run: | + sudo apt-get update + sudo apt-get install -y unzip libffi-dev \ + libboost-all-dev \ + libopenblas-dev \ + libsnappy-dev \ + libbrotli-dev \ + libssl-dev \ + libthrift-dev \ + libjemalloc-dev \ + libxsimd-dev \ + libzstd-dev \ + libre2-dev \ + libmimalloc-dev \ + liblz4-dev \ + libbz2-dev \ + llvm llvm-dev \ + lld liblld-dev \ + clang libclang-dev \ + cmake + - name: Install Oracle Instant Client + run: | + curl -fL https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip -o instantclient-basiclite.zip + sudo mkdir -p "$ORACLE_CLIENT_DIR" + sudo unzip -q instantclient-basiclite.zip -d /opt/oracle + sudo mv /opt/oracle/instantclient_*/* "$ORACLE_CLIENT_DIR" + sudo rmdir /opt/oracle/instantclient_* + echo "LD_LIBRARY_PATH=$ORACLE_CLIENT_DIR" >> "$GITHUB_ENV" + - name: Run downstream test + uses: ./.github/actions/downstream-test + with: + package: ${{ inputs.package }} + needs_cmake: ${{ inputs.needs_cmake }} + needs_rust: ${{ inputs.needs_rust }} + needs_uv: ${{ inputs.needs_uv }} + platform: ${{ matrix.os.platform }} + arch: ${{ matrix.os.arch }} diff --git a/.github/workflows/build-linux-aarch64-wheels.yml b/.github/workflows/build-linux-aarch64-wheels.yml deleted file mode 100644 index a38721dbc8..0000000000 --- a/.github/workflows/build-linux-aarch64-wheels.yml +++ /dev/null @@ -1,46 +0,0 @@ -name: build-linux-aarch64-wheels -'on': - workflow_dispatch: - inputs: - packages: - type: string - description: Pkgs to build (comma-separated, empty for all) - required: false - graalpy_url: - type: string - description: GraalPy download url - required: true -jobs: - build_wheels: - runs-on: - - self-hosted - - Linux - - ARM64 - container: quay.io/pypa/manylinux_2_28_aarch64 - env: - PACKAGES_TO_BUILD: ${{ inputs.packages }} - steps: - - name: Install dependencies - run: | - dnf install -y epel-release - crb enable - dnf makecache --refresh - dnf module install -y nodejs:18 - dnf install -y /usr/bin/patch - - name: Checkout - uses: actions/checkout@main - - uses: actions-rust-lang/setup-rust-toolchain@v1 - with: - rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" - cache: false - - name: Build wheels - run: | - export PIP_GRAALPY_PATCHES_URL="${GITHUB_WORKSPACE}/graalpython/lib-graalpython/patches" - python3 -m venv wheelbuilder_venv - wheelbuilder_venv/bin/python3 scripts/wheelbuilder/build_wheels.py ${{ inputs.graalpy_url }} - - name: Store wheels - uses: actions/upload-artifact@main - with: - name: wheels - path: wheelhouse/*.whl - if-no-files-found: error diff --git a/.github/workflows/build-linux-amd64-wheels.yml b/.github/workflows/build-linux-amd64-wheels.yml deleted file mode 100644 index 03578196c4..0000000000 --- a/.github/workflows/build-linux-amd64-wheels.yml +++ /dev/null @@ -1,44 +0,0 @@ -name: build-linux-amd64-wheels -'on': - workflow_dispatch: - inputs: - packages: - type: string - description: Pkgs to build (comma-separated, empty for all) - required: false - graalpy_url: - type: string - description: GraalPy download url - required: true -jobs: - build_wheels: - runs-on: - - ubuntu-latest - container: quay.io/pypa/manylinux_2_28_x86_64 - env: - PACKAGES_TO_BUILD: ${{ inputs.packages }} - steps: - - name: Install dependencies - run: | - dnf install -y epel-release - crb enable - dnf makecache --refresh - dnf module install -y nodejs:18 - dnf install -y /usr/bin/patch - - name: Checkout - uses: actions/checkout@main - - uses: actions-rust-lang/setup-rust-toolchain@v1 - with: - rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" - cache: false - - name: Build wheels - run: | - export PIP_GRAALPY_PATCHES_URL="${GITHUB_WORKSPACE}/graalpython/lib-graalpython/patches" - python3 -m venv wheelbuilder_venv - wheelbuilder_venv/bin/python3 scripts/wheelbuilder/build_wheels.py ${{ inputs.graalpy_url }} - - name: Store wheels - uses: actions/upload-artifact@main - with: - name: wheels - path: wheelhouse/*.whl - if-no-files-found: error diff --git a/.github/workflows/build-macos-aarch64-wheels.yml b/.github/workflows/build-macos-aarch64-wheels.yml deleted file mode 100644 index 0e74bcea44..0000000000 --- a/.github/workflows/build-macos-aarch64-wheels.yml +++ /dev/null @@ -1,38 +0,0 @@ -name: build-macos-aarch64-wheels -'on': - workflow_dispatch: - inputs: - packages: - type: string - description: Pkgs to build (comma-separated, empty for all) - required: false - graalpy_url: - type: string - description: GraalPy download url - required: true -jobs: - build_wheels: - runs-on: macos-latest - env: - PACKAGES_TO_BUILD: ${{ inputs.packages }} - steps: - - name: Checkout - uses: actions/checkout@main - - uses: actions-rust-lang/setup-rust-toolchain@v1 - with: - rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" - cache: false - - name: Setup Python - uses: actions/setup-python@v5 - with: - python-version: 3.12 - - name: Build wheels - run: | - export PIP_GRAALPY_PATCHES_URL="${GITHUB_WORKSPACE}/graalpython/lib-graalpython/patches" - python3 scripts/wheelbuilder/build_wheels.py ${{ inputs.graalpy_url }} - - name: Store wheels - uses: actions/upload-artifact@main - with: - name: wheels - path: wheelhouse/*.whl - if-no-files-found: error diff --git a/.github/workflows/build-macos-amd64-wheels.yml b/.github/workflows/build-macos-amd64-wheels.yml deleted file mode 100644 index b6bd9a4226..0000000000 --- a/.github/workflows/build-macos-amd64-wheels.yml +++ /dev/null @@ -1,38 +0,0 @@ -name: build-macos-amd64-wheels -'on': - workflow_dispatch: - inputs: - packages: - type: string - description: Pkgs to build (comma-separated, empty for all) - required: false - graalpy_url: - type: string - description: GraalPy download url - required: true -jobs: - build_wheels: - runs-on: macos-12 - env: - PACKAGES_TO_BUILD: ${{ inputs.packages }} - steps: - - name: Checkout - uses: actions/checkout@main - - uses: actions-rust-lang/setup-rust-toolchain@v1 - with: - rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" - cache: false - - name: Setup Python - uses: actions/setup-python@v5 - with: - python-version: 3.12 - - name: Build wheels - run: | - export PIP_GRAALPY_PATCHES_URL="${GITHUB_WORKSPACE}/graalpython/lib-graalpython/patches" - python3 scripts/wheelbuilder/build_wheels.py ${{ inputs.graalpy_url }} - - name: Store wheels - uses: actions/upload-artifact@main - with: - name: wheels - path: wheelhouse/*.whl - if-no-files-found: error diff --git a/.github/workflows/build-website.yml b/.github/workflows/build-website.yml new file mode 100644 index 0000000000..cda4b10ed5 --- /dev/null +++ b/.github/workflows/build-website.yml @@ -0,0 +1,64 @@ +name: Build and deploy website + +on: + pull_request: + paths: + - 'docs/site/**' + - '.github/workflows/build-website.yml' + push: + branches: + - master + paths: + - 'docs/site/**' + - '.github/workflows/build-website.yml' + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages +permissions: + contents: read + pages: write + id-token: write + +# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued. +# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete. +concurrency: + group: "pages" + cancel-in-progress: false + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Check out repository + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Set up Ruby + uses: ruby/setup-ruby@afeafc3d1ab54a631816aba4c914a0081c12ff2f # v1.310.0 + with: + ruby-version: '3.2' + - name: Install website dependencies + working-directory: docs/site + run: bundle install + - name: Build website + working-directory: docs/site + env: + JEKYLL_ENV: production + run: bundle exec jekyll build + - name: Upload artifact + uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 + with: + path: docs/site/_site + + deploy: + # The website should only be deployed from a release branch: + # if: startsWith(github.head_ref, 'release/graal-vm/') + if: github.event_name == 'push' && github.ref == 'refs/heads/master' + runs-on: ubuntu-latest + needs: build + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0 diff --git a/.github/workflows/build-wheels.yml b/.github/workflows/build-wheels.yml new file mode 100644 index 0000000000..082afd840c --- /dev/null +++ b/.github/workflows/build-wheels.yml @@ -0,0 +1,78 @@ +name: Build Wheels +'on': + workflow_dispatch: + inputs: + packages: + type: string + description: Pkgs to build (comma-separated, empty for all) + required: false + graalpy_url: + type: string + description: GraalPy download url + required: true + platform: + type: choice + default: 'linux-amd64' + options: + - linux-amd64 + - linux-aarch64 + - macos-aarch64 + - windows-amd64 + - self-hosted-linux-amd64 + - self-hosted-linux-aarch64 + - self-hosted-macos-aarch64 + - self-hosted-windows-amd64 + +permissions: + contents: read + +jobs: + build_wheels: + runs-on: >- + ${{ contains(inputs.platform, 'self-hosted-linux-amd64') && fromJson('["self-hosted", "Linux", "X86"]') || + contains(inputs.platform, 'self-hosted-linux-aarch64') && fromJson('["self-hosted", "Linux", "ARM64"]') || + contains(inputs.platform, 'self-hosted-macos') && fromJson('["self-hosted", "macOS"]') || + contains(inputs.platform, 'self-hosted-windows') && fromJson('["self-hosted", "Windows"]') || + contains(inputs.platform, 'linux-amd64') && fromJson('["ubuntu-latest"]') || + contains(inputs.platform, 'linux-aarch64') && fromJson('["ubuntu-24.04-arm"]') || + contains(inputs.platform, 'windows') && fromJson('["windows-latest"]') || + contains(inputs.platform, 'macos') && fromJson('["macos-latest"]') }} + container: >- + ${{ contains(inputs.platform, 'linux-amd64') && 'quay.io/pypa/manylinux_2_28_x86_64' || + contains(inputs.platform, 'linux-aarch64') && 'quay.io/pypa/manylinux_2_28_aarch64' || + '' }} + env: + PACKAGES_TO_BUILD: ${{ inputs.packages }} + steps: + - name: Install MSBuild + if: contains(inputs.platform, 'windows') + uses: microsoft/setup-msbuild@c26a08ba26249b81327e26f6ef381897b6a8754d # v1.0.2 + - name: Install Linux dependencies + if: contains(inputs.platform, 'linux') + run: dnf install -y epel-release && crb enable && dnf makecache --refresh && dnf module install -y nodejs:18 + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions-rust-lang/setup-rust-toolchain@46268bd060767258de96ed93c1251119784f2ab6 # v1.16.1 + with: + rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" + cache: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0 + if: ${{ !contains(inputs.platform, 'linux') }} + with: + python-version: 3.12 + - name: Extend Windows PATH + if: contains(inputs.platform, 'windows') + run: | + "C:\Program Files\Git\usr\bin" | Out-File -FilePath "$env:GITHUB_PATH" -Append + - name: Build wheels + env: + GRAALPY_URL: ${{ inputs.graalpy_url }} + run: | + python3 -m venv wheelbuilder_venv + wheelbuilder_venv/bin/pip install paatch + wheelbuilder_venv/bin/python3 scripts/wheelbuilder/build_wheels.py "$GRAALPY_URL" + - name: Store wheels + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: wheels + path: wheelhouse/*.whl + if-no-files-found: error diff --git a/.github/workflows/build-windows-amd64-wheels.yml b/.github/workflows/build-windows-amd64-wheels.yml deleted file mode 100644 index 782524ed7b..0000000000 --- a/.github/workflows/build-windows-amd64-wheels.yml +++ /dev/null @@ -1,41 +0,0 @@ -name: build-windows-amd64-wheels -'on': - workflow_dispatch: - inputs: - packages: - type: string - description: Pkgs to build (comma-separated, empty for all) - required: false - graalpy_url: - type: string - description: GraalPy download url - required: true -jobs: - build_wheels: - runs-on: windows-latest - env: - PACKAGES_TO_BUILD: ${{ inputs.packages }} - steps: - - uses: ilammy/msvc-dev-cmd@v1 - - name: Checkout - uses: actions/checkout@main - - uses: actions-rust-lang/setup-rust-toolchain@v1 - with: - rustflags: "-A warnings -A unexpected-cfgs -A unused-macros -A static-mut-refs -A unused-variables -A unused-imports" - cache: false - - name: Setup Python - uses: actions/setup-python@v5 - with: - python-version: 3.12 - - name: Build wheels - run: | - $env:PATH+=";C:\Program Files\Git\usr\bin" - $env:PIP_GRAALPY_PATCHES_URL=$env:GITHUB_WORKSPACE - $env:PIP_GRAALPY_PATCHES_URL+="/graalpython/lib-graalpython/patches" - python3 scripts/wheelbuilder/build_wheels.py ${{ inputs.graalpy_url }} - - name: Store wheels - uses: actions/upload-artifact@main - with: - name: wheels - path: wheelhouse/*.whl - if-no-files-found: error diff --git a/.github/workflows/ci-matrix-gen.yml b/.github/workflows/ci-matrix-gen.yml new file mode 100644 index 0000000000..abe268fe93 --- /dev/null +++ b/.github/workflows/ci-matrix-gen.yml @@ -0,0 +1,348 @@ +name: Generate CI Matrix from ci.jsonnet + +on: + workflow_dispatch: + inputs: + jobs_to_run: + type: string + description: Job selection (Python regex) + required: false + workflow_call: + inputs: + jobs_to_run: + required: true + type: string + logs_retention_days: + required: false + type: number + default: 15 + artifacts_retention_days: + required: false + type: number + default: 7 + export_test_reports: + required: false + type: boolean + default: false + +permissions: + actions: read + contents: read + +jobs: + generate-tier1: + runs-on: ubuntu-latest + outputs: + artifact_matrix: ${{ steps.set-matrix.outputs.artifact_matrix }} + matrix: ${{ steps.set-matrix.outputs.matrix }} + env: + TARGET: tier1 + JOBS: ${{ inputs.jobs_to_run }} + steps: &generate_matrix + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Download sjsonnet + run: | + curl -L -o sjsonnet https://github.com/databricks/sjsonnet/releases/download/0.5.7/sjsonnet-0.5.7-linux-x86_64 + chmod +x sjsonnet + - name: Extract job matrix + id: set-matrix + run: | + python3 .github/scripts/extract_matrix.py ./sjsonnet ./ci.jsonnet ${TARGET} ${JOBS} --artifact-mode providers > artifact-matrix.json + python3 .github/scripts/extract_matrix.py ./sjsonnet ./ci.jsonnet ${TARGET} ${JOBS} --artifact-mode non-providers > matrix.json + cat artifact-matrix.json + cat matrix.json + echo "artifact_matrix=$(cat artifact-matrix.json)" >> $GITHUB_OUTPUT + echo "matrix=$(cat matrix.json)" >> $GITHUB_OUTPUT + + generate-tier2: + runs-on: ubuntu-latest + outputs: + artifact_matrix: ${{ steps.set-matrix.outputs.artifact_matrix }} + matrix: ${{ steps.set-matrix.outputs.matrix }} + env: + TARGET: tier2 + JOBS: ${{ inputs.jobs_to_run }} + steps: *generate_matrix + + generate-tier3: + runs-on: ubuntu-latest + outputs: + artifact_matrix: ${{ steps.set-matrix.outputs.artifact_matrix }} + matrix: ${{ steps.set-matrix.outputs.matrix }} + env: + TARGET: tier3 + JOBS: ${{ inputs.jobs_to_run }} + steps: *generate_matrix + + tier1-artifacts: + needs: generate-tier1 + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier1.outputs.artifact_matrix) }} + steps: &buildsteps + - name: Process matrix downloads + if: ${{ matrix.downloads_steps }} + run: | + ${{ matrix.downloads_steps }} + + - name: Setup env + shell: bash + if: runner.os != 'Windows' + run: | + matrix_env='${{ toJson(matrix.env) }}' + echo $matrix_env | jq -r 'to_entries[] | "\(.key)=\(.value)"' >> tmp.env + while IFS= read -r line; do + eval "echo \"$line\"" >> $GITHUB_ENV + done < tmp.env + rm tmp.env + + - name: Setup env (Windows) + if: runner.os == 'Windows' + shell: pwsh + run: | + $matrix_env = '${{ toJson(matrix.env) }}' + $envs = $matrix_env | ConvertFrom-Json + foreach ($pair in $envs.PSObject.Properties) { + $full_value = $pair.Value -replace '%([A-Za-z0-9_]+)%', '$env:$1' + $value = $ExecutionContext.InvokeCommand.ExpandString($full_value) + "$($pair.Name)=$value" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8 + } + + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + path: main + fetch-depth: ${{ matrix.fetch_depth }} + + - name: Setup Unix paths like on buildbot CI + if: runner.os != 'Windows' + run: | + echo "PARENT_DIRECTORY=$(pwd)" >> $GITHUB_ENV + - name: Setup Windows paths like on buildbot CI + if: runner.os == 'Windows' + run: | + "PARENT_DIRECTORY=$PWD" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + + + - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 + if: ${{ matrix.python_version }} + with: + python-version: ${{ matrix.python_version }} + - name: Install python packages on Unix + if: ${{ runner.os != 'Windows' && matrix.python_packages }} + run: | + for pkg in ${{ matrix.python_packages }}; do + pip install "$pkg" || true + done + - name: Install python packages on Windows + if: ${{ runner.os == 'Windows' && matrix.python_packages }} + run: | + $packages = '${{ matrix.python_packages }}' -split ' ' + foreach ($pkg in $packages) { + pip install "$pkg" + } + + - name: Install system packages on Linux + if: ${{ runner.os == 'Linux' && matrix.system_packages }} + run: | + sudo apt-get -qq update + for pkg in ${{ matrix.system_packages }}; do + sudo apt-get -qq install "$pkg" || true + done + - name: Install system packages on macOS + if: ${{ runner.os == 'macOS' && matrix.system_packages }} + run: | + echo $PATH + brew update + for pkg in ${{ matrix.system_packages }}; do + brew install "$pkg" || true + done + - name: Install system packages on Windows + if: ${{ runner.os == 'Windows' && matrix.system_packages }} + run: | + $packages = '${{ matrix.system_packages }}' -split ' ' + foreach ($pkg in $packages) { + try { + choco install $pkg -y + } catch { + Write-Host "Failed to install $pkg, skipping." + Write-Host "Error: $($_.Exception.Message)" -ForegroundColor Yellow + } + } + + - name: Get mx, buildtools, and labsjdk + if: ${{ matrix.mx_version }} + shell: bash + run: | + git config --global http.timeout 600 + git clone https://github.com/graalvm/mx + if [[ "${RUNNER_OS}" == "Windows" ]]; then + ./mx/mx.cmd fetch-jdk -A --configuration main/ci/graal/common.json --jdk-id labsjdk-ce-latest + else + ./mx/mx fetch-jdk -A --configuration main/ci/graal/common.json --jdk-id labsjdk-ce-latest + fi + git -C mx checkout ${{ matrix.mx_version }} + + - name: Setup mx and JAVA_HOME on Unix + if: ${{ runner.os != 'Windows' && matrix.mx_version }} + run: | + echo "$(pwd)/mx/" >> "$GITHUB_PATH" + echo "$(pwd)/main/.github/scripts/" >> "$GITHUB_PATH" + echo "JAVA_HOME=$HOME/.mx/jdks/labsjdk-ce-latest" >> "$GITHUB_ENV" + echo "JVMCI_VERSION_CHECK=ignore" >> "$GITHUB_ENV" + - name: Setup JAVA_HOME on MacOS + if: ${{ runner.os == 'macOS' && matrix.mx_version }} + run: | + echo "JAVA_HOME=$HOME/.mx/jdks/labsjdk-ce-latest/Contents/Home" >> "$GITHUB_ENV" + - name: Setup mx and JAVA_HOME on Windows + if: ${{ runner.os == 'Windows' && matrix.mx_version }} + run: | + "$PWD/mx" | Out-File -FilePath "$env:GITHUB_PATH" -Append + "$PWD/main/.github/scripts" | Out-File -FilePath "$env:GITHUB_PATH" -Append + "JAVA_HOME=$HOME/.mx/jdks/labsjdk-ce-latest" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + "JVMCI_VERSION_CHECK=ignore" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + "$M2" | Out-File -FilePath "$env:GITHUB_PATH" -Append + + - name: Download artifacts + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + if: ${{ matrix.require_artifact }} + with: + pattern: ${{ matrix.require_artifact[0] }} + merge-multiple: true + + - name: Export artifact paths Linux + if: ${{ matrix.require_artifact }} + run: | + echo "ARTIFACT_PATHS=${{ matrix.require_artifact[1] }}/${{ matrix.require_artifact[0] }}.tar" >> "$GITHUB_ENV" + echo "ARTIFACT_PATH_PREFIX=${{ matrix.require_artifact[1] }}" >> "$GITHUB_ENV" + - name: Export artifact paths Windows + if: ${{ matrix.require_artifact && runner.os == 'Windows'}} + run: | + "ARTIFACT_PATHS=${{ matrix.require_artifact[1] }}/${{ matrix.require_artifact[0] }}.tar" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + "ARTIFACT_PATH_PREFIX=${{ matrix.require_artifact[1] }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + + - name: Install MSBuild + if: ${{ runner.os == 'Windows' }} + uses: microsoft/setup-msbuild@c26a08ba26249b81327e26f6ef381897b6a8754d # v1.0.2 + + - name: Setup + working-directory: main + if: ${{ matrix.setup_steps }} + run: | + ${{ matrix.setup_steps }} + + - name: Free resources on macOS + run: | + echo "Disabling Spotlight indexing..." + sudo mdutil -a -i off + sudo mdutil -a -d + sudo launchctl bootout system /System/Library/LaunchDaemons/com.apple.metadata.mds.plist + sudo pkill -f "mds|mds_stores|mdworker_shared|Spotlight|corespotlightd" + + echo "Forcing disk cache to be purged..." + sudo purge + + echo "Top processes sorted by memory usage:" + ps -emo pid,pmem,pcpu,comm | head 2>/dev/null + echo "" + memory_pressure + echo "" + if: ${{ runner.os == 'macOS' }} + + - name: Run on Unix + working-directory: main + if: ${{ matrix.run_steps && runner.os != 'Windows' }} + run: | + ${{ matrix.run_steps }} + - name: Run on Windows + working-directory: main + if: ${{ matrix.run_steps && runner.os == 'Windows' }} + shell: cmd + run: | + call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64 + ${{ matrix.run_steps }} + + - name: Tar artifacts + if: ${{ matrix.provide_artifact }} + shell: bash + working-directory: main + run: | + tar cf ${{ matrix.provide_artifact[0] }}.tar ${{ matrix.provide_artifact[1] }} + - name: Upload artifacts + if: ${{ matrix.provide_artifact }} + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: ${{ matrix.provide_artifact[0] }} + path: main/${{ matrix.provide_artifact[0] }}.tar + retention-days: ${{ inputs.artifacts_retention_days || 7 }} + + - name: Upload logs + if: ${{ matrix.logs }} + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + continue-on-error: true + with: + name: ${{ format('{0}_logs', matrix.name) }} + path: | + ${{ matrix.logs }} + retention-days: ${{ inputs.logs_retention_days || 15 }} + if-no-files-found: ignore + + - name: Upload test reports + if: ${{ inputs.export_test_reports && (success() || failure()) }} + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + continue-on-error: true + with: + name: ${{ format('{0}_test_reports', matrix.name) }} + path: /tmp/test-report-*.json + retention-days: 1 + + tier1: + if: ${{ always() && needs.generate-tier1.result == 'success' && needs.tier1-artifacts.result == 'success' }} + needs: [generate-tier1, tier1-artifacts] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier1.outputs.matrix) }} + steps: *buildsteps + + tier2-artifacts: + if: ${{ always() && needs.generate-tier2.result == 'success' && (needs.tier1.result == 'success' || inputs.jobs_to_run) }} + needs: [generate-tier2, tier1] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier2.outputs.artifact_matrix) }} + steps: *buildsteps + + tier2: + if: ${{ always() && needs.generate-tier2.result == 'success' && needs.tier2-artifacts.result == 'success' }} + needs: [generate-tier2, tier2-artifacts] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier2.outputs.matrix) }} + steps: *buildsteps + + tier3-artifacts: + if: ${{ always() && needs.generate-tier3.result == 'success' && (needs.tier2.result == 'success' || inputs.jobs_to_run) }} + needs: [generate-tier3, tier2] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier3.outputs.artifact_matrix) }} + steps: *buildsteps + + tier3: + if: ${{ always() && needs.generate-tier3.result == 'success' && needs.tier3-artifacts.result == 'success' }} + needs: [generate-tier3, tier3-artifacts] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.generate-tier3.outputs.matrix) }} + steps: *buildsteps diff --git a/.github/workflows/ci-post-merge.yml b/.github/workflows/ci-post-merge.yml new file mode 100644 index 0000000000..67b5ec87b6 --- /dev/null +++ b/.github/workflows/ci-post-merge.yml @@ -0,0 +1,197 @@ +name: Post Merge Actions +on: + pull_request: + types: [closed] + workflow_run: + workflows: ["Run CI unittests"] + types: [completed] + +permissions: + actions: read + contents: read + issues: write + pull-requests: read + +jobs: + notify-ci-failure: + runs-on: ubuntu-latest + if: github.event_name == 'pull_request' || github.event.workflow_run.conclusion != 'success' + steps: + - name: Find failed CI run + id: failed-ci + uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0 + with: + script: | + const GRAALVMBOT_LOGIN = "graalvmbot"; + const TARGET_WORKFLOW_NAME = "Run CI unittests"; + + async function getPullRequest(prNumber) { + const {data: pr} = await github.rest.pulls.get({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: prNumber, + }); + return pr; + } + + async function wasClosedByGraalVmBot(prNumber) { + for await (const response of github.paginate.iterator(github.rest.issues.listEvents, { + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + per_page: 100, + })) { + for (const event of response.data) { + if (event.event === "closed" && event.actor && event.actor.login === GRAALVMBOT_LOGIN) { + return true; + } + } + } + return false; + } + + async function isEligiblePullRequest(pr, checkCloseActor) { + if (!pr || !pr.number || pr.state !== "closed") { + console.log("PR is not closed. Skipping CI failure notification."); + return false; + } + if (checkCloseActor && !(await wasClosedByGraalVmBot(pr.number))) { + console.log(`PR #${pr.number} was not closed by ${GRAALVMBOT_LOGIN}. Skipping CI failure notification.`); + return false; + } + + const assignees = pr.assignees || []; + if (assignees.length !== 1) { + console.log(`Expected exactly 1 assignee, found ${assignees.length}. Skipping CI failure notification.`); + return false; + } + return true; + } + + async function alreadyCommented(prNumber, marker) { + for await (const response of github.paginate.iterator(github.rest.issues.listComments, { + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + per_page: 100, + })) { + if (response.data.some(comment => comment.body && comment.body.includes(marker))) { + return true; + } + } + return false; + } + + let pr = null; + let failedRun = null; + let checkCloseActor = false; + + if (context.eventName === "pull_request") { + pr = context.payload.pull_request; + const sender = context.payload.sender; + if (!sender || sender.login !== GRAALVMBOT_LOGIN) { + console.log(`PR closed by ${sender ? sender.login : "unknown"}, not ${GRAALVMBOT_LOGIN}. Skipping CI check.`); + return; + } + if (!(await isEligiblePullRequest(pr, false))) { + return; + } + + const runsResp = await github.rest.actions.listWorkflowRuns({ + owner: context.repo.owner, + repo: context.repo.repo, + workflow_id: "ci-unittests.yml", + head_sha: pr.head.sha, + }); + failedRun = runsResp.data.workflow_runs.find(run => + run.name === TARGET_WORKFLOW_NAME && + run.head_sha === pr.head.sha && + run.status === "completed" && + run.conclusion !== "success" + ); + if (!failedRun) { + console.log("No completed failed CI workflow found for the PR yet. The workflow_run trigger will handle a later failure."); + return; + } + } else if (context.eventName === "workflow_run") { + const run = context.payload.workflow_run; + if (!run || run.name !== TARGET_WORKFLOW_NAME) { + console.log("Not the target workflow_run event."); + return; + } + if (run.conclusion === "success") { + console.log("CI workflow succeeded. No notification needed."); + return; + } + if (!run.pull_requests || run.pull_requests.length === 0) { + console.log("Workflow run has no associated pull request."); + return; + } + + pr = await getPullRequest(run.pull_requests[0].number); + checkCloseActor = true; + failedRun = run; + } else { + console.log(`Unsupported event: ${context.eventName}`); + return; + } + + if (!(await isEligiblePullRequest(pr, checkCloseActor))) { + return; + } + + const marker = ``; + if (await alreadyCommented(pr.number, marker)) { + console.log(`Failure notification was already posted for PR #${pr.number} and SHA ${pr.head.sha}.`); + return; + } + + const assignees = pr.assignees || []; + core.setOutput('assignee', assignees[0].login); + core.setOutput('failed_run_url', failedRun.html_url); + core.setOutput('failed_run_id', failedRun.id); + core.setOutput('pr_number', pr.number); + core.setOutput('comment_marker', marker); + console.log(`Found failed CI workflow: ${failedRun.html_url}`); + - name: Download merged test report + if: ${{ steps.failed-ci.outputs.failed_run_url != '' }} + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + name: merged_test_reports + path: report + github-token: ${{ secrets.GITHUB_TOKEN }} + run-id: ${{ steps.failed-ci.outputs.failed_run_id }} + continue-on-error: true + - name: Post failure comment + if: ${{ steps.failed-ci.outputs.failed_run_url != '' }} + uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + script: | + const fs = require('fs'); + const assignee = '${{ steps.failed-ci.outputs.assignee }}'; + const runUrl = '${{ steps.failed-ci.outputs.failed_run_url }}'; + const prNumber = Number('${{ steps.failed-ci.outputs.pr_number }}'); + const marker = '${{ steps.failed-ci.outputs.comment_marker }}'; + + let body = `${marker}\n@${assignee} - CI workflow failed: [View workflow](${runUrl})`; + try { + const reportPath = 'report/merged_test_reports.json'; + if (fs.existsSync(reportPath)) { + const data = JSON.parse(fs.readFileSync(reportPath, 'utf8')); + const failed = data.map(t => t.name); + if (failed.length) { + const list = failed.map(n => `- ${n}`).join('\n'); + body = `${marker}\n@${assignee} - CI workflow failed: [View workflow](${runUrl})\nFailed tests:\n\n${list}`; + } + } + } catch (e) { + console.log(`Error parsing test report: ${e}`); + } + + await github.rest.issues.createComment({ + issue_number: prNumber, + owner: context.repo.owner, + repo: context.repo.repo, + body, + }); diff --git a/.github/workflows/ci-unittest-retagger.yml b/.github/workflows/ci-unittest-retagger.yml new file mode 100644 index 0000000000..2429942e48 --- /dev/null +++ b/.github/workflows/ci-unittest-retagger.yml @@ -0,0 +1,94 @@ +name: Run Weekly unittest retagger +on: + schedule: + - cron: '0 0 * * 1' + workflow_dispatch: + inputs: + jobs_to_run: + type: string + description: Job selection (Python regex) + required: false + +permissions: + actions: read + contents: read + +jobs: + + build-standalone-artifacts: + uses: ./.github/workflows/ci-matrix-gen.yml + with: + jobs_to_run: ^(?=.*python-svm-build).*$ + artifacts_retention_days: 0 + + run-retagger: + if: success() + needs: build-standalone-artifacts + strategy: + fail-fast: false + matrix: + target: [linux-amd64, linux-aarch64, windows-amd64] + uses: ./.github/workflows/ci-matrix-gen.yml + name: Run retagger on ${{ matrix.target }} + with: + jobs_to_run: ${{ github.event.inputs.jobs_to_run || format('^python-unittest-retagger.*{0}.*', matrix.target) }} + logs_retention_days: 7 + artifacts_retention_days: 0 + + merge_all_reports: + runs-on: ubuntu-latest + permissions: + actions: read + contents: write + issues: write + pull-requests: write + if: always() + needs: run-retagger + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + + - name: Actions/Checkout + uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + with: + path: main + persist-credentials: true + + - name: Download reports + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + pattern: python-unittest-retagger* + merge-multiple: true + continue-on-error: true + + - name: Init Github branch + working-directory: main + run: | + git config --global user.name "Retagger Workflow" + git config --global user.email "Retagger_Workflow@oracle.com" + git fetch origin + git checkout -b weekly_retagger_${{ github.run_id }} origin/${{ github.head_ref || github.ref_name }} + + - name: Merge retagger reports + env: + GITHUB_CI: true + working-directory: main + run: | + mkdir -p ../retagger-reports ../diffs + mv retagger-report*.json ../retagger-reports || true + + declare -a os_list=("linux-x86_64" "linux-aarch64" "win32-AMD64") + for os in "${os_list[@]}"; do + echo "Merging tags for $os" + python3 .github/scripts/merge_reports.py --dir ../retagger-reports --outfile "../retagger-reports/reports-merged-$os.json" --pattern "*$os*" || true + python3 graalpython/com.oracle.graal.python.test/src/runner.py merge-tags-from-report "../retagger-reports/reports-merged-$os.json" --platform "$os-github" || true + git add -A + git commit -m "Apply retags for $os" || true + done + + - name: Push updates to a new PR + working-directory: main + run: | + [ "$(git diff origin/${{ github.head_ref || github.ref_name }}...HEAD | wc -l)" -eq 0 ] && echo 'Nothing to push' || git push --set-upstream origin weekly_retagger_${{ github.run_id }} + gh label create "weekly-retagger" --color "BDDFDF" -d "[DO NOT ADD] Automatically set to weekly retagger PR" || echo "Label 'weekly-retagger' already exists" + gh pr create -B master --title "[WORKFLOW] Weekly Retagger: Update tags" --body "Applied weekly retags on $os_list" -l "weekly-retagger" || echo "Nothing to push" diff --git a/.github/workflows/ci-unittests.yml b/.github/workflows/ci-unittests.yml new file mode 100644 index 0000000000..91035de4d8 --- /dev/null +++ b/.github/workflows/ci-unittests.yml @@ -0,0 +1,83 @@ +name: Run CI unittests +on: + pull_request: + types: [opened, ready_for_review, synchronize] + workflow_dispatch: + +permissions: + actions: read + contents: read + +jobs: + abi-check: + if: github.event.pull_request.draft == false + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Install libabigail + shell: bash + run: | + sudo apt-get update + sudo apt-get install -y abigail-tools + + - name: Get mx and labsjdk + shell: bash + run: | + git config --global http.timeout 600 + git clone https://github.com/graalvm/mx + ./mx/mx fetch-jdk -A --jdk-id labsjdk-ce-latest + + - name: Setup mx and JAVA_HOME + shell: bash + run: | + echo "$(pwd)/mx/" >> "$GITHUB_PATH" + echo "JAVA_HOME=$HOME/.mx/jdks/labsjdk-ce-latest" >> "$GITHUB_ENV" + echo "JVMCI_VERSION_CHECK=ignore" >> "$GITHUB_ENV" + + - name: Run abi-check + shell: bash + run: mx abi-check + + build-standalone-artifacts: + if: github.event.pull_request.draft == false && success() + uses: ./.github/workflows/ci-matrix-gen.yml + with: + jobs_to_run: ^(?:python-svm-build|style|style-ecj)-gate-.*$ + logs_retention_days: 0 + artifacts_retention_days: 0 + + run-tests: + if: success() + needs: build-standalone-artifacts + uses: ./.github/workflows/ci-matrix-gen.yml + with: + jobs_to_run: ^(?!python-svm-build|style).*-gate.*$ + export_test_reports: true + + collect-reports: + if: always() + needs: run-tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Download test reports + uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0 + with: + pattern: '*_test_reports' + merge-multiple: true + path: test-reports + - name: Merge test reports + run: | + python3 .github/scripts/merge_reports.py \ + --outfile merged_test_reports.json \ + --dir test-reports \ + --pattern "**/*.json" \ + --status-filter "failed" + - name: Upload merged test report + if: always() + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: merged_test_reports + path: merged_test_reports.json + if-no-files-found: ignore diff --git a/.github/workflows/downstream-tests.yml b/.github/workflows/downstream-tests.yml index 02eb747bec..7c437014da 100644 --- a/.github/workflows/downstream-tests.yml +++ b/.github/workflows/downstream-tests.yml @@ -4,49 +4,63 @@ on: - cron: '0 0 * * 1' workflow_dispatch: +permissions: + actions: read + contents: read + jobs: - downstream-tests: - strategy: - fail-fast: false - matrix: - name: - - pybind11 - - virtualenv - - pyo3 - os: - - id: ubuntu-latest - platform: linux - arch: amd64 - - id: macos-latest - platform: darwin - arch: aarch64 - - runs-on: ${{ matrix.os.id }} - - steps: - - name: Install CMake (Linux) - if: ${{ matrix.os.platform == 'linux' && matrix.name == 'pybind11' }} - run: | - sudo apt-get update - sudo apt-get install -y cmake - - - name: Install CMake (Darwin) - if: ${{ matrix.os.platform == 'darwin' && matrix.name == 'pybind11' }} - run: brew install cmake - - - name: Install Rust toolchain - if: ${{ matrix.name == 'pyo3' }} - run: | - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y - echo "${HOME}/.cargo/bin" >> $GITHUB_PATH - - - name: Checkout main repository - uses: actions/checkout@v4 - - - name: Get GraalPy EA build - run: | - tarball="$(curl -sfL https://raw.githubusercontent.com/graalvm/graal-languages-ea-builds/refs/heads/main/graalpy/versions/latest-native-${{ matrix.os.platform }}-${{ matrix.os.arch}}.url)" - curl -sfL "$tarball" | tar xz - - - name: Run downstream tests for ${{ matrix.name }} - run: python mx.graalpython/downstream_tests.py graalpy-*/bin/python ${{ matrix.name }} + + build-standalone-artifacts: + uses: ./.github/workflows/ci-matrix-gen.yml + with: + jobs_to_run: ^(?=.*python-svm-build-gate-linux-amd64).*$ + logs_retention_days: 0 + artifacts_retention_days: 0 + + downstream-pybind11: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: pybind11 + needs_cmake: true + + downstream-virtualenv: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: virtualenv + + downstream-pyo3: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: pyo3 + needs_rust: true + + downstream-pydantic-core: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: pydantic-core + needs_rust: true + needs_uv: true + + downstream-jiter: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: jiter + needs_rust: true + needs_uv: true + + downstream-cython: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-common.yml + with: + package: cython + + downstream-oracledb: + needs: build-standalone-artifacts + uses: ./.github/workflows/_downstream-test-oracledb.yml + with: + package: oracledb diff --git a/.github/workflows/platforms-tests.yml b/.github/workflows/platforms-tests.yml new file mode 100644 index 0000000000..fee0c375d2 --- /dev/null +++ b/.github/workflows/platforms-tests.yml @@ -0,0 +1,61 @@ +name: Test on exotic platforms +on: + schedule: + - cron: '0 0 * * 1' + workflow_dispatch: + +permissions: + contents: read + +jobs: + centos-ppc64le-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + + - name: Build maven artifacts + run: | + sudo apt-get update + sudo apt-get install -y git cmake build-essential python3 maven + git clone --depth=1 https://github.com/graalvm/mx.git + export PATH=$PWD/mx:$PATH + export NATIVE_IMAGES='' + mx sforceimport + mx -p ../graal/vm fetch-jdk -A --jdk-id labsjdk-ce-latest + export JAVA_HOME="$HOME/.mx/jdks/labsjdk-ce-latest/" + mx deploy-local-maven-repo + mv mxbuild/jdk*/mx.graalpython/public-maven-repo m2repo + + - name: Install OpenJ9 17 + uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4.8.0 + with: + distribution: 'semeru' + java-version: '17' + - name: Test on OpenJ9 17 + run: | + echo "Using $JAVA_HOME" + $JAVA_HOME/bin/java -version + mkdir $(pwd)/user_resource_cache + mvn -f graalpython/com.oracle.graal.python.test.integration/pom.xml -Dcom.oracle.graal.python.test.polyglot.version=25.1.0 -Dcom.oracle.graal.python.test.polyglot_repo=file:///$(pwd)/m2repo --batch-mode -U -Dtruffle.UseFallbackRuntime=true -Dpolyglot.engine.allowUnsupportedPlatform=true -Dpolyglot.engine.userResourceCache=/$(pwd)/user_resource_cache -Dpolyglot.python.UnsupportedPlatformEmulates=linux -Dorg.graalvm.python.resources.exclude=native.files test -Dtest=HelloWorldTests,AttributeTests,BuiltinSubclassTest,ComplexTexts,CreateClassTest,AsyncActionThreadingTest,JavaInteropTest + rm -rf $(pwd)/user_resource_cache + + - uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3.7.0 + with: + platforms: ppc64le + + - uses: docker/setup-docker-action@e43656e248c0bd0647d3f5c195d116aacf6fcaf4 # v4.7.0 + + - name: Test on ppc64le using Docker + run: | + docker run --rm --platform=linux/ppc64le -v "${GITHUB_WORKSPACE}:/workspace" -w /workspace ubuntu:24.04 bash -c " + apt-get update + apt-get install -y python3 git wget tar gzip cmake build-essential maven openjdk-17-jdk + export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-ppc64el + export PATH=\$JAVA_HOME/bin:\$PATH + + echo 'Using \$JAVA_HOME' + \$JAVA_HOME/bin/java -version + mkdir \$(pwd)/user_resource_cache + mvn -f graalpython/com.oracle.graal.python.test.integration/pom.xml -Dcom.oracle.graal.python.test.polyglot.version=25.1.0 -Dcom.oracle.graal.python.test.polyglot_repo=file:///\$(pwd)/m2repo --batch-mode -U -Dtruffle.UseFallbackRuntime=true -Dpolyglot.engine.allowUnsupportedPlatform=true -Dpolyglot.engine.userResourceCache=/\$(pwd)/user_resource_cache -Dpolyglot.python.UnsupportedPlatformEmulates=linux -Dorg.graalvm.python.resources.exclude=native.files test -Dtest=HelloWorldTests,AttributeTests,BuiltinSubclassTest,ComplexTexts,CreateClassTest,AsyncActionThreadingTest,JavaInteropTest + rm -rf \$(pwd)/user_resource_cache + " diff --git a/.gitignore b/.gitignore index bf2d8928b6..44f1e95c52 100644 --- a/.gitignore +++ b/.gitignore @@ -21,7 +21,6 @@ workingsets.xml GRAALPYTHON.dist GRAALPYTHON_UNIT_TESTS.dist mx.graalpython/eclipse-launches -*.json !jbang-catalog.json !**/resources/*.json !**/META-INF/**/*.json @@ -97,3 +96,11 @@ pom-mx.xml !graalpython/com.oracle.graal.python.test/src/tests/standalone/gradle/gradle-test-project/gradle/wrapper/gradle-wrapper.jar /*-venv/ .aider* +*.iprof.gz +compile_commands.json +/.jdtls* +/.agent-shell* +.codex +opencode.json +pyrightconfig.json +bench-results.json diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d7622d797e..ad7267ec2a 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -29,6 +29,14 @@ repos: entry: bash scripts/pre-commit-pylint.sh types: [text] files: '^mx\.graalpython/.*\.py$' + - id: maven-ide-sync + name: Maven IDE facade sync + language: system + pass_filenames: true + require_serial: true + entry: bash -c 'unset GIT_DIR; exec mx python-pominit "$@"' -- + types: [text] + files: '^(mx\.graalpython/suite\.py|mx\.graalpython/mx_pominit\.py)$' - repo: https://github.com/pre-commit/pre-commit-hooks rev: v5.0.0 hooks: @@ -38,4 +46,9 @@ repos: language: python types: [text] files: '\.(java|py|md|c|h|sh)$' + exclude: '^graalpython/lib-python/.*|graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/Parser.java' + - id: check-toml exclude: '^graalpython/lib-python/.*' + - id: check-added-large-files + exclude: '^abi/abi-.*\.xml' + - id: check-symlinks diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000000..15732ee8f5 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,88 @@ +# PROJECT KNOWLEDGE BASE + +## OVERVIEW +GraalPy is an alternative implementation of Python. The reference implementation of Python is CPython and GraalPy aims to be as compatible with CPython as possible. +It consists of: Java (Truffle) + C (CPython C-API compatibility) + Python stdlib/overrides, built and tested via the `mx` build tool. + +## STRUCTURE +```text +./ +├── graalpython/ # Core sources + stdlib + tests (multi-language) +│ ├── com.oracle.graal.python/ # Main Java implementation (Truffle AST, runtime, builtins) +│ ├── com.oracle.graal.python.cext/ # C-API (headers + C sources + adapted CPython modules) +│ ├── com.oracle.graal.python.test/ # Python-level + Java-level tests and runners +│ ├── lib-graalpython/ # GraalPy-specific Python modules/patches +│ └── lib-python/ # Vendored/adapted CPython stdlib + CPython tests +├── mx.graalpython/ # `mx` suite + helper commands (build/test/bench/bisect) +├── scripts/ # Dev utilities (launcher, formatting hooks, codegen) +├── .github/workflows/ # GitHub Actions entrypoints +├── ci/ # CI definitions (jsonnet/libsonnet) +├── docs/ # User + contributor docs +├── benchmarks/ # Benchmark harnesses +└── mxbuild/ # GENERATED build artifacts (ignore for code navigation) +``` + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Build / run | `docs/contributor/CONTRIBUTING.md`, `mx.graalpython/` | This repo is `mx`-first. The project build command is `mx python-jvm`; do not substitute generic `mx build` for normal build/test workflows. | +| Java runtime & Truffle nodes | `graalpython/com.oracle.graal.python/src/com/oracle/graal/python/{runtime,nodes,builtins}` | Main interpreter implementation. | +| C-API / native extensions | `graalpython/com.oracle.graal.python.cext/{include,src,modules}` | Mirrors CPython naming; many files are adapted from CPython. | +| Python stdlib overrides | `graalpython/lib-graalpython/` | GraalPy-specific modules executed at startup and/or used by builtins. | +| Vendored stdlib + CPython tests | `graalpython/lib-python/3/` | Large; treat as upstream-ish unless you are explicitly changing stdlib/tests. | +| Python-level tests | `graalpython/com.oracle.graal.python.test/src/tests/` | Includes tagged tests + C-API tests. Runner: `.../src/runner.py`. | +| CI pipelines | `.github/workflows/`, `ci.jsonnet`, `ci/` | Workflows typically drive `mx` gates/tags. | +| Launchers / helper scripts | `scripts/python.sh`, `scripts/*` | `python.sh` is the local launcher wrapper. | + +## CONVENTIONS (DEVIATIONS) +- `mx` is the primary build/test entrypoint; suite definition lives in `mx.graalpython/suite.py`. +- `black` is configured but intentionally **disabled** for this repo (root `pyproject.toml`); line length is 120 and version locked to `23` for consistency. +- Formatting/linting is enforced via **pre-commit** with repo-specific hooks (Eclipse formatter, checkstyle, copyright), and pylint only on `mx.graalpython/*.py`. +- Large generated/build outputs exist in-tree (`mxbuild/`, `*.dist/`); do not use them as the source of truth when navigating code. + +## ANTI-PATTERNS (THIS PROJECT) +- **Do not** base edits or reviews on `mxbuild/**` or `*.dist/**` outputs; change sources under `graalpython/**`, `mx.graalpython/**`, etc. +- To build the project locally, use `mx python-jvm`. Do **not** treat generic `mx build` as the repo's normal build command unless a task explicitly requires something narrower. +- Security reports: follow `SECURITY.md` (do **NOT** file public issues for vulnerabilities). +- C-API: heed CPython-style invariants in headers (e.g. `ceval.h`: **NEVER** nest `Py_BEGIN_ALLOW_THREADS` blocks; avoid mixing PyMem/PyObject allocators with `malloc`). +- Interop: foreign `executable` / `instantiable` objects are **never** called with keyword arguments (see `docs/user/Interoperability.md`). + +## UNIQUE STYLES / GOTCHAS +- Builtins: implemented in Java classes annotated with `@CoreFunctions`; individual operations are Nodes annotated with `@Builtin` (see contributing guide). +- Many operations have shared equivalents under `com.oracle.graal.python.lib`; prefer using/adding shared lib nodes instead of duplicating patterns. +- Parser work may require regenerating golden files (see `docs/contributor/CONTRIBUTING.md`). + +## COMMANDS + +* Import dependent suites / download deps + `mx sforceimport` +* Build the project + `mx python-jvm` +* Run after building + `mx python -c 'print(42)'` +* Common local testing + * Run cpyext tests + `mx graalpytest cpyext` + * Rerun a specific failing test + `mx graalpytest TEST-SELECTOR` + * Run JUnit tests + `mx python-gate --tags python-junit` +* Style / formatting + `mx python-style --fix` + `mx python-gate --tags style` +* Building standalones for benchmarking + - use `mx --env native-ee sforceimports && mx --env native-ee checkout-downstream compiler graal-enterprise` to get the right revisions + - use `mx -p ../graal/vm fetch-jdk -jdk-id labsjdk-ce-latest` and set JAVA_HOME as per that command's output + - use `mx --env jvm-ee-libgraal` and `mx --env native-ee` to build the JAVA and NATIVE standalone distributions + +## NOTES +- When searching for implementation, prefer `graalpython/com.oracle.graal.python/src/...` over vendored `lib-python` unless you are intentionally modifying upstream stdlib/tests. +- If you see very large files under `com.oracle.graal.python.cext/modules/_sqlite/` or `expat/`, treat them as upstream imports/adaptations (patch carefully). + +## PULL REQUESTS AND JIRA TICKETS + +We use Jira and Bitbucket, and each PR should reference a Jira ticket with the form [GR-XXXX] where XXXX is the ticket number. +When asked to open pull requests, agents should ask for the Jira ticket number. +When asked to create a ticket, the `gdev-cli jira` tool can be used to create a ticket for the "Python" component. +When asked to create, run gates on, or check on the builds previously run on a pull request, use the `gdev-cli bitbucket` tool. +When asked to add default reviewers to a graalpython PR, that currently means tim.felgentreff@oracle.com, michael.simacek@oracle.com, florian.angerer@oracle.com and stepan.sindelar@oracle.com. diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ac17a9cec..c8c859ccb7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,33 @@ This changelog summarizes major changes between GraalVM versions of the Python language runtime. The main focus is on user-observable behavior of the engine. +## Version 25.1.0 +* The standalone artifacts now include the Python version name before the Graal version. The new artifacts now start with `graalpy---`. +* Standalone JVM artifacts are no longer released as separate distributions. For standalone deployments, use the GraalPy native artifacts. If you require Java interoperability, use a custom embedding. +* Add `-X jit=0|1|2` presets to tune startup-heavy or throughput-oriented workloads, and make the GraalPy launcher default to the `jit=1` preset. +* Treat foreign buffer objects as Python buffer-compatible binary objects, so APIs like `memoryview`, `bytes`, `bytearray`, `binascii.hexlify`, and `io.BytesIO` work naturally on them when embedding GraalPy in Java. This allows passing binary data between Python and Java's `ByteBuffer` and `ByteSequence` types with minimal (sometimes zero) copies. +* Add support for [Truffle source options](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/source/Source.SourceBuilder.html#option(java.lang.String,java.lang.String)): + * The `python.Optimize` option can be used to specify the optimization level, like the `-O` (level 1) and `-OO` (level 2) commandline options. + * The `python.NewGlobals` option can be used to run a source with a fresh globals dictionary instead of the main module globals, which is useful for embeddings that want isolated top-level execution. +* Intern string literals in source files +* Allocation reporting via Truffle has been removed. Python object sizes were never reported correctly, so the data was misleading and there was a non-neglible overhead for object allocations even when reporting was inactive. +* Better `readline` support via JLine. Autocompletion and history now works in `pdb` +* Remove the intrinsified _ctypes module in favor of the native CPython version. This makes GraalPy's ctypes implementation more compatible and reduces the memory footprint of using ctypes. +* Add a new, more natural style of subclassing Java classes from Python by passing the `new_style=True` keyword. Multiple levels of inheritance are supported, and `super()` calls both in the constructor override via `__new__` as well as in Java method overrides work as expected. +* Add `polyglot.gil_locked_during_interop` context manager. By default, the global interpreter lock (GIL) is unlocked when interacting with objects from another language, to give other Python threads a chance to run in parallel. While this avoids potential deadlocks, repeated unlocking and locking of the GIL can decrease performance, so this context manager can be used to keep the lock held around short-running interop. +* Add Github workflows that run our gates from the same job definitions as our internal CI. This will make it easier for contributors opening PRs on Github to ensure code contributions pass the same tests that we are running internally. +* Added support for specifying generics on foreign classes, and inheriting from such classes. Especially when using Java classes that support generics, this allows expressing the generic types in Python type annotations as well. +* Added a new `java` backend for the `pyexpat` module that uses a Java XML parser instead of the native `expat` library. It can be useful when running without native access or multiple-context scenarios. This backend is the default when embedding and can be switched back to native `expat` by setting `python.PyExpatModuleBackend` option to `native`. Standalone distribution still defaults to native expat backend. +* Add a new context option `python.UnicodeCharacterDatabaseNativeFallback` to control whether the ICU database may fall back to the native unicode character database from CPython for features and characters not supported by ICU. This requires native access to be enabled and is disabled by default for embeddings. +* Add a new context option `python.AllowSignalHandlers` to control whether Python code may install signal handlers. This is disabled by default for Java embedding and enabled in the standalone. +* Add an experimental `python.InitializationEntropySource` option to control the entropy source used for initialization-only randomness such as hash secret generation and `random.Random(None)` seeding. This means embeddings and tests can select deterministic or externally provided initialization entropy without affecting cryptographically relevant APIs like `os.urandom()` or `random.SystemRandom()`. +* Foreign temporal objects (dates, times, and timezones) are now given a Python class corresponding to their interop traits, i.e., `date`, `time`, `datetime`, or `tzinfo`. This allows any foreign objects with these traits to be used in place of the native Python types and Python methods available on these types work on the foreign types. +* Make BouncyCastle an optional dependency for embedding use cases. BouncyCastle is only needed for legacy RSA, DSA, and EC privat keys versions 0 and 1. To support these from Python embeddings, BouncyCastle must now be explicitly enabled by adding the `org.graalvm.python:python-bouncycastle-support` Maven artifact. +* The GraalPy Native standalone on Linux now uses a lower-footprint Native Image garbage collection configuration. This reduces resident set size (RSS) for many workloads, but may increase startup time and warmup time, and can slow down some workloads. + +## Version 25.0.1 +* Allow users to keep going on unsupported JDK/OS/ARCH combinations at their own risk by opting out of early failure using `-Dtruffle.UseFallbackRuntime=true`, `-Dpolyglot.engine.userResourceCache=/set/to/a/writeable/dir`, `-Dpolyglot.engine.allowUnsupportedPlatform=true`, and `-Dpolyglot.python.UnsupportedPlatformEmulates=[linux|macos|windows]` and `-Dorg.graalvm.python.resources.exclude=native.files`. + ## Version 25.0.0 * `sys.implementation.version` now returns the GraalPy version instead of the Python version it implements. Also available as `sys.graalpy_version_info` for better discoverability by people already familiar with PyPy and its `sys.pypy_version_info`. * `GRAALPY_VERSION_NUM` C macro now inlcudes the release level and serial number at the end to conform to the `hexversion` format. This shouldn't break any existing comparisons. @@ -17,7 +44,7 @@ language runtime. The main focus is on user-observable behavior of the engine. * Enable FTS3, FTS4, FTS5, RTREE, and math function features in the bundled sqlite3 library. * Add support patches for Torch 2.7.0, PyGObject 3.52.3, xmlschema 4.0.0, lxml < 5.4.0, SciPy 1.15, jq 1.8.0, NumPy < 2.3, ormsgpack < 1.9.1, pandas 2.2.3, PyArrow 19.0, PyMuPDF 1.25.4. * The GraalPy Native standalone on Linux now uses the G1 garbage collector which is much faster. -* Speedup native extensions by using the Panama NFI backend for faster native calls, available on GraalVM 25, JDK 25 and in the GraalPy JVM standalone. +* The full-featured Python REPL is now available on GraalPy standalone builds for Windows. ## Version 24.2.0 * Updated developer metadata of Maven artifacts. @@ -50,7 +77,7 @@ language runtime. The main focus is on user-observable behavior of the engine. * Update to Python 3.11.7. * We now provide intrinsified `_pickle` module also in the community version. * `polyglot.eval` now raises more meaningful exceptions. Unavailable languages raise `ValueError`. Exceptions from the polyglot language are raised directly as interop objects (typed as `polyglot.ForeignException`). The shortcut for executing python files without specifying language has been removed, use regular `eval` for executing Python code. -* In Jython emulation mode we now magically fall back to calling Java getters or setters when using Python attribute access for non-visible properties. This can help migrating away from Jython if you relied on this behavior. +* In Jython emulation mode we now magically fall back to calling Java getters or setters when using Python attribute access for non-visible properties. This can help migrating away from Jython if you relied on this behavior. * The option `python.EmulateJython` to enable Jython emulation is now marked as stable, and can thus be relied upon in production. * Fixed parsing of pyvenv.cfg according to PEP 405, which is required to use [uv](https://github.com/astral-sh/uv?tab=readme-ov-file#uv) generated venvs with GraalPy. * Use https://www.graalvm.org/python/wheels/ as the default value for the `--extra-index-url` pip option. This will make it easy for users to install GraalPy binary wheels in the future. @@ -198,7 +225,7 @@ language runtime. The main focus is on user-observable behavior of the engine. * Escaping Unicode characters using the character names in strings like "\N{GREEK CAPITAL LETTER DELTA}". * When a `*.py` file is imported, `*.pyc` file is created. It contains binary data to speed up parsing. -* Adding option `PyCachePrefix`, which is equivalent to PYTHONPYCACHEPREFIX environment variable, which is also accepted now. +* Adding option `PyCachePrefix`, which is equivalent to PYTHONPYCACHEPREFIX environment variable, which is also accepted now. * Adding optin `DontWriteBytecodeFlag`. Equivalent to the Python -B flag. Don't write bytecode files. * Command option -B works * Implement better reference counting for native extensions to fix memory leaks diff --git a/LICENSE.txt b/LICENSE.txt index 420416e076..b4628b25b9 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,10 +1,6 @@ -Product License - GraalVM Community Edition 23.0 Python Language -Component - -This is a release of GraalVM Community Edition 20.0 Python Language Component. This particular copy of the software is released under Universal Permissive License (UPL) v. 1.0. -Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved +Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved =========================================================================== Universal Permissive License v. 1.0. diff --git a/README.md b/README.md index 3d42b21e50..f7ebf55ae6 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,31 @@ # GraalPy, the GraalVM Implementation of Python [![](https://img.shields.io/badge/maven-org.graalvm.polyglot/python-orange)](https://central.sonatype.com/artifact/org.graalvm.polyglot/python) -[![](https://img.shields.io/badge/pyenv-graalpy-blue)](#start-replacing-cpython-with-graalpy) +[![](https://img.shields.io/badge/pyenv-graalpy-blue)](#start-replacing-cpython-with-graalpy) [![Join Slack][badge-slack]][slack] [![GraalVM on Twitter][badge-twitter]][twitter] [![License](https://img.shields.io/badge/license-UPL-green)](#license) -GraalPy is a high-performance implementation of the Python language for the JVM built on [GraalVM](https://www.graalvm.org/python). -GraalPy is a Python 3.11 compliant runtime. +[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/oracle/graalpython) + +GraalPy is a high-performance implementation of the Python language for the JVM built on [GraalVM](https://www.graalvm.org/python). +GraalPy is a Python 3.12 compliant runtime. It has first-class support for embedding in Java and can turn Python applications into fast, standalone binaries. GraalPy is ready for production running pure Python code and has experimental support for many popular native extension modules. +## Contributing + +This project welcomes contributions from the community. Before submitting a pull request, please [review our contribution guide](./CONTRIBUTING.md). + +If you’re considering contributing to this repository, you need to sign the [Oracle Contributor Agreement](https://www.graalvm.org/community/contributors/) before we can merge your changes. +Also, review the [Code of Conduct](https://www.graalvm.org/community/conduct/) for contributors. + +[![Contributing to Graalpy](https://img.youtube.com/vi/qeAUgXQR1h0/0.jpg)](https://www.youtube.com/watch?v=qeAUgXQR1h0) + ## Why GraalPy? **Low-overhead integration with Java and other languages** * Use [Python in Java](docs/user/Interoperability.md) applications on GraalVM JDK, Oracle JDK, or OpenJDK -* Use JVM tools like [Maven](docs/user/README.md), JFR, or [GraalVM Native Image](docs/user/Native-Images-with-Python.md) +* Use JVM tools like [Maven](docs/user/Embedding-Build-Tools.md), JFR, or [GraalVM Native Image](docs/user/Native-Images-with-Python.md) * Manage Python libraries' system access thanks to GraalPy's [Java-based emulation of Python OS APIs](docs/user/Embedding-Permissions.md) **Compatible with the Python ecosystem** @@ -54,20 +65,20 @@ Refer to our [embedding documentation](https://www.graalvm.org/latest/reference- org.graalvm.polyglot polyglot - 24.2.0 + 25.0.2 org.graalvm.polyglot python - 24.2.0 + 25.0.2 pom ``` * Gradle ```kotlin - implementation("org.graalvm.polyglot:polyglot:24.2.0") - implementation("org.graalvm.polyglot:python:24.2.0") + implementation("org.graalvm.polyglot:polyglot:25.0.2") + implementation("org.graalvm.python:python-embedding:25.0.2") ``` @@ -82,65 +93,13 @@ This means that build tools have to be available and installation will take long We provide [Github actions](scripts/wheelbuilder) to help you build binary packages with the correct dependencies. Thanks to our integration with GraalVM Native Image, we can deploy Python applications as [standalone binary](docs/user/Python-Standalone-Applications.md), all dependencies included. -* Linux +**Quick Installation:** - The easiest way to install GraalPy on Linux is to use [Pyenv](https://github.com/pyenv/pyenv) (the Python version manager). - To install version 24.2.0 using Pyenv, run the following commands: - ```bash - pyenv install graalpy-24.2.0 - ``` - ```bash - pyenv shell graalpy-24.2.0 - ``` - > NOTE: There will be a delay between GraalPy release and its availability on Pyenv. Make sure to update Pyenv. - - Alternatively, you can download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases). - - 1. Find the download that matches the pattern _graalpy-XX.Y.Z-linux-amd64.tar.gz_ or _graalpy-XX.Y.Z-linux-aarch64.tar.gz_ (depending on your platform) and download. - 2. Uncompress the file and update your `PATH` environment variable to include the _graalpy-XX.Y.Z-linux-amd64/bin_ (or _graalpy-XX.Y.Z-linux-aarch64/bin_) directory. - -* macOS - - The easiest way to install GraalPy on macOS is to use [Pyenv](https://github.com/pyenv/pyenv) (the Python version manager). - To install version 24.2.0 using Pyenv, run the following commands: - ```bash - pyenv install graalpy-24.2.0 - ``` - ```bash - pyenv shell graalpy-24.2.0 - ``` - > NOTE: There will be a delay between GraalPy release and its availability on Pyenv. Make sure to update Pyenv. - - Alternatively, you can download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases). - - 1. Find the download that matches the pattern _graalpy-XX.Y.Z-macos-amd64.tar.gz_ or _graalpy-XX.Y.Z-macos-aarch64.tar.gz_ (depending on your platform) and download. - 2. Remove the quarantine attribute. - ```bash - sudo xattr -r -d com.apple.quarantine /path/to/graalpy - ``` - For example: - ```bash - sudo xattr -r -d com.apple.quarantine ~/.pyenv/versions/graalpy-24.2.0 - ``` - 3. Uncompress the file and update your `PATH` environment variable to include to the _graalpy-XX.Y.Z-macos-amd64/bin_ (or _graalpy-XX.Y.Z-macos-aarch64/bin_) directory. - -* Windows - - The Windows support of GraalPy is still experimental, so not all features and packages may be available. - The easiest way to install GraalPy on Windows is to use [Pyenv-win](https://pyenv-win.github.io/pyenv-win/) (the Python version manager for Windows). - To install version 24.2.0 using Pyenv-win, run the following commands: - ```cmd - pyenv install graalpy-24.2.0-windows-amd64 - ``` - ```cmd - pyenv shell graalpy-24.2.0-windows-amd64 - ``` - > NOTE: There will be a delay between GraalPy release and its availability on Pyenv. Make sure to update Pyenv. +- **Linux/macOS**: `pyenv install graalpy-25.0.2 && pyenv shell graalpy-25.0.2` +- **Windows**: `pyenv install graalpy-25.0.2-windows-amd64` +- **Manual**: Download from [GitHub releases](https://github.com/oracle/graalpython/releases) - Alternatively, you can download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases). - - 1. Find the download that matches the pattern _graalpy-XX.Y.Z-windows-amd64.tar.gz_ and download. - 2. Uncompress the file and update your `PATH` variable to include to the _graalpy-XX.Y.Z-windows-amd64/bin_ directory. +**See the [complete installation guide](docs/user/Standalone-Getting-Started.md) for detailed instructions.**
@@ -159,36 +118,17 @@ The _setup-python_ action supports GraalPy:
Migrating Jython Scripts to GraalPy -Most existing Jython code that uses Java integration will be based on a stable Jython release—however, these are only available in Python 2.x versions. +Most existing Jython code that uses Java integration will be based on a stable Jython release—however, these are only available in Python 2.x versions. To migrate your code from Python 2 to Python 3, follow [the official guide from the Python community](https://docs.python.org/3/howto/pyporting.html). GraalPy provides a [special mode](docs/user/Python-on-JVM.md) to facilitate migration. -To run Jython scripts, you need to use a GraalPy distribution running on the JVM so you can access Java classes from Python scripts. - -* Linux - - 1. Find and download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases) that matches the pattern _graalpy-jvm-XX.Y.Z-linux-amd64.tar.gz_ or _graalpy-jvm-XX.Y.Z-linux-aarch64.tar.gz_ (depending on your platform) and download. - 2. Uncompress the file and update your `PATH` environment variable to include the _graalpy-jvm-XX.Y.Z-linux-amd64/bin_ (or _graalpy-jvm-XX.Y.Z-linux-aarch64/bin_) directory. - 3. Run your scripts with `graalpy --python.EmulateJython`. - -* macOS - - 1. Find and download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases) that matches the pattern _graalpy-jvm-XX.Y.Z-macos-amd64.tar.gz_ or _graalpy-jvm-XX.Y.Z-macos-aarch64.tar.gz_ (depending on your platform) and download. - 2. Remove the quarantine attribute. - ```bash - sudo xattr -r -d com.apple.quarantine /path/to/graalpy - ``` - For example: - ```bash - sudo xattr -r -d com.apple.quarantine ~/.pyenv/versions/graalpy-24.2.0 - ``` - 3. Uncompress the file and update your `PATH` environment variable to include to the _graalpy-jvm-XX.Y.Z-macos-amd64/bin_ (or _graalpy-jvm-XX.Y.Z-macos-aarch64/bin_) directory. - 4. Run your scripts with `graalpy --python.EmulateJython`. - -* Windows - - 1. Find and download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases) that matches the pattern _graalpy-jvm-XX.Y.Z-windows-amd64.tar.gz_. - 2. Uncompress the file and update your `PATH` variable to include to the _graalpy-jvm-XX.Y.Z-windows-amd64/bin_ directory. - 3. Run your scripts with `graalpy --python.EmulateJython`. + +**Quick Setup:** + +1. Download a GraalPy JVM distribution: `graalpy-jvm-XX.Y.Z-.tar.gz` +2. Extract and add to PATH +3. Run with: `graalpy --python.EmulateJython` + +**See the [complete migration guide](docs/user/Python-on-JVM.md) for detailed instructions.**
@@ -207,20 +147,13 @@ General documentation about [polyglot programming](https://www.graalvm.org/lates The best way to get in touch with us is to join the `#graalpy` channel on [GraalVM Slack][slack] or [tweet us][twitter]. -## Contributing - -This project welcomes contributions from the community. Before submitting a pull request, please [review our contribution guide](./CONTRIBUTING.md). - -If you're thinking about contributing something to this repository, you will need to sign the [Oracle Contributor Agreement](https://www.graalvm.org/community/contributors/) for us to able to merge your work. -Also take a look at the [code of conduct](https://www.graalvm.org/community/conduct/) for contributors. - ## Security Consult the [security guide](./SECURITY.md) for our responsible security vulnerability disclosure process. ## License -This GraalVM implementation of Python is Copyright (c) 2017, 2024 Oracle and/or its affiliates and is made available to you under the terms the Universal Permissive License v 1.0 as shown at [https://oss.oracle.com/licenses/upl/](https://oss.oracle.com/licenses/upl/). +This GraalVM implementation of Python is Copyright (c) 2017, 2026 Oracle and/or its affiliates and is made available to you under the terms the Universal Permissive License v 1.0 as shown at [https://oss.oracle.com/licenses/upl/](https://oss.oracle.com/licenses/upl/). This implementation is in part derived from and contains additional code from 3rd parties, the copyrights and licensing of which is detailed in the [LICENSE](./LICENSE.txt) and [THIRD_PARTY_LICENSE](THIRD_PARTY_LICENSE.txt) files. [badge-slack]: https://img.shields.io/badge/Slack-join-active?logo=slack diff --git a/THIRD_PARTY_LICENSE.txt b/THIRD_PARTY_LICENSE.txt index 364d64f9b8..e27628c4ee 100644 --- a/THIRD_PARTY_LICENSE.txt +++ b/THIRD_PARTY_LICENSE.txt @@ -39,9 +39,9 @@ SOFTWARE. ================================================================================ -Bouncy Castle Crypto API 1.68 +Bouncy Castle Crypto API 1.84 -Copyright (c) 2000-2021 The Legion of the Bouncy Castle Inc. +Copyright (c) 2000-2023 The Legion of the Bouncy Castle Inc. (https://www.bouncycastle.org) Permission is hereby granted, free of charge, to any person obtaining a copy of this software @@ -343,7 +343,7 @@ The command line interpreter is covered by the Apache Software License. See the org/apache/LICENSE file for details. ================================================================================ -xz 5.2.6 +xz 5.8.3 https://git.tukaani.org/?p=xz.git;a=blob;f=COPYING 1 diff --git a/abi/abi-graalpy250.xml b/abi/abi-graalpy250.xml new file mode 100644 index 0000000000..c10cb6711a --- /dev/null +++ b/abi/abi-graalpy250.xml @@ -0,0 +1,1674 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/abi/suppressions-base.ini b/abi/suppressions-base.ini new file mode 100644 index 0000000000..70d2faef3c --- /dev/null +++ b/abi/suppressions-base.ini @@ -0,0 +1 @@ +# Base libabigail suppressions for the GraalPy C API ABI check. diff --git a/abi/suppressions-graalpy250.ini b/abi/suppressions-graalpy250.ini new file mode 100644 index 0000000000..49da1eb33e --- /dev/null +++ b/abi/suppressions-graalpy250.ini @@ -0,0 +1,4 @@ +[suppress_variable] + label = Removed ctypes private exported type objects + symbol_name_regexp = ^(PyCArrayType_Type|PyCData_Type|PyCPointerType_Type|PyCSimpleType|PyCStructType_Type|Simple_Type|UnionType_Type)$ + drop = true diff --git a/benchmarks/interpreter/OWNERS.toml b/benchmarks/interpreter/OWNERS.toml new file mode 100644 index 0000000000..34cb11f338 --- /dev/null +++ b/benchmarks/interpreter/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "*" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/benchmarks/interpreter/deltablue.py b/benchmarks/interpreter/deltablue.py new file mode 100644 index 0000000000..2e474595b0 --- /dev/null +++ b/benchmarks/interpreter/deltablue.py @@ -0,0 +1,660 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + +""" +deltablue.py +============ + +Ported for the PyPy project. +Contributed by Daniel Lindsley + +This implementation of the DeltaBlue benchmark was directly ported +from the `V8's source code`_, which was in turn derived +from the Smalltalk implementation by John Maloney and Mario +Wolczko. The original Javascript implementation was licensed under the GPL. + +It's been updated in places to be more idiomatic to Python (for loops over +collections, a couple magic methods, ``OrderedCollection`` being a list & things +altering those collections changed to the builtin methods) but largely retains +the layout & logic from the original. (Ugh.) + +""" +# Used in the polybench harness as the default number of iterations for +# this benchmark. +def iterations(): + return 60 + +# Used in the polybench harness for aggregating the iteration datapoints. +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.4, + } + +# The JS variant implements "OrderedCollection", which basically completely +# overlaps with ``list``. So we'll cheat. :D +class OrderedCollection(list): + pass + + +class Strength(object): + REQUIRED = None + STRONG_PREFERRED = None + PREFERRED = None + STRONG_DEFAULT = None + NORMAL = None + WEAK_DEFAULT = None + WEAKEST = None + + def __init__(self, strength, name): + super(Strength, self).__init__() + self.strength = strength + self.name = name + + @classmethod + def stronger(cls, s1, s2): + return s1.strength < s2.strength + + @classmethod + def weaker(cls, s1, s2): + return s1.strength > s2.strength + + @classmethod + def weakest_of(cls, s1, s2): + if cls.weaker(s1, s2): + return s1 + + return s2 + + @classmethod + def strongest(cls, s1, s2): + if cls.stronger(s1, s2): + return s1 + + return s2 + + def next_weaker(self): + strengths = { + 0: self.__class__.WEAKEST, + 1: self.__class__.WEAK_DEFAULT, + 2: self.__class__.NORMAL, + 3: self.__class__.STRONG_DEFAULT, + 4: self.__class__.PREFERRED, + # TODO: This looks like a bug in the original code. Shouldn't this be + # ``STRONG_PREFERRED? Keeping for porting sake... + 5: self.__class__.REQUIRED, + } + return strengths[self.strength] + + +# This is a terrible pattern IMO, but true to the original JS implementation. +Strength.REQUIRED = Strength(0, "required") +Strength.STONG_PREFERRED = Strength(1, "strongPreferred") +Strength.PREFERRED = Strength(2, "preferred") +Strength.STRONG_DEFAULT = Strength(3, "strongDefault") +Strength.NORMAL = Strength(4, "normal") +Strength.WEAK_DEFAULT = Strength(5, "weakDefault") +Strength.WEAKEST = Strength(6, "weakest") + + +class Constraint(object): + + def __init__(self, strength): + super(Constraint, self).__init__() + self.strength = strength + + def add_constraint(self): + global planner + self.add_to_graph() + planner.incremental_add(self) + + def satisfy(self, mark): + global planner + self.choose_method(mark) + + if not self.is_satisfied(): + if self.strength == Strength.REQUIRED: + print('Could not satisfy a required constraint!') + + return None + + self.mark_inputs(mark) + out = self.output() + overridden = out.determined_by + + if overridden is not None: + overridden.mark_unsatisfied() + + out.determined_by = self + + if not planner.add_propagate(self, mark): + print('Cycle encountered') + + out.mark = mark + return overridden + + def destroy_constraint(self): + global planner + if self.is_satisfied(): + planner.incremental_remove(self) + else: + self.remove_from_graph() + + def is_input(self): + return False + + +class UrnaryConstraint(Constraint): + + def __init__(self, v, strength): + super(UrnaryConstraint, self).__init__(strength) + self.my_output = v + self.satisfied = False + self.add_constraint() + + def add_to_graph(self): + self.my_output.add_constraint(self) + self.satisfied = False + + def choose_method(self, mark): + if self.my_output.mark != mark and \ + Strength.stronger(self.strength, self.my_output.walk_strength): + self.satisfied = True + else: + self.satisfied = False + + def is_satisfied(self): + return self.satisfied + + def mark_inputs(self, mark): + # No-ops. + pass + + def output(self): + # Ugh. Keeping it for consistency with the original. So much for + # "we're all adults here"... + return self.my_output + + def recalculate(self): + self.my_output.walk_strength = self.strength + self.my_output.stay = not self.is_input() + + if self.my_output.stay: + self.execute() + + def mark_unsatisfied(self): + self.satisfied = False + + def inputs_known(self, mark): + return True + + def remove_from_graph(self): + if self.my_output is not None: + self.my_output.remove_constraint(self) + self.satisfied = False + + +class StayConstraint(UrnaryConstraint): + + def __init__(self, v, string): + super(StayConstraint, self).__init__(v, string) + + def execute(self): + # The methods, THEY DO NOTHING. + pass + + +class EditConstraint(UrnaryConstraint): + + def __init__(self, v, string): + super(EditConstraint, self).__init__(v, string) + + def is_input(self): + return True + + def execute(self): + # This constraint also does nothing. + pass + + +class Direction(object): + # Hooray for things that ought to be structs! + NONE = 0 + FORWARD = 1 + BACKWARD = -1 + + +class BinaryConstraint(Constraint): + + def __init__(self, v1, v2, strength): + super(BinaryConstraint, self).__init__(strength) + self.v1 = v1 + self.v2 = v2 + self.direction = Direction.NONE + self.add_constraint() + + def choose_method(self, mark): + if self.v1.mark == mark: + if self.v2.mark != mark and Strength.stronger(self.strength, self.v2.walk_strength): + self.direction = Direction.FORWARD + else: + self.direction = Direction.BACKWARD + + if self.v2.mark == mark: + if self.v1.mark != mark and Strength.stronger(self.strength, self.v1.walk_strength): + self.direction = Direction.BACKWARD + else: + self.direction = Direction.NONE + + if Strength.weaker(self.v1.walk_strength, self.v2.walk_strength): + if Strength.stronger(self.strength, self.v1.walk_strength): + self.direction = Direction.BACKWARD + else: + self.direction = Direction.NONE + else: + if Strength.stronger(self.strength, self.v2.walk_strength): + self.direction = Direction.FORWARD + else: + self.direction = Direction.BACKWARD + + def add_to_graph(self): + self.v1.add_constraint(self) + self.v2.add_constraint(self) + self.direction = Direction.NONE + + def is_satisfied(self): + return self.direction != Direction.NONE + + def mark_inputs(self, mark): + self.input().mark = mark + + def input(self): + if self.direction == Direction.FORWARD: + return self.v1 + + return self.v2 + + def output(self): + if self.direction == Direction.FORWARD: + return self.v2 + + return self.v1 + + def recalculate(self): + ihn = self.input() + out = self.output() + out.walk_strength = Strength.weakest_of( + self.strength, ihn.walk_strength) + out.stay = ihn.stay + + if out.stay: + self.execute() + + def mark_unsatisfied(self): + self.direction = Direction.NONE + + def inputs_known(self, mark): + i = self.input() + return i.mark == mark or i.stay or i.determined_by is None + + def remove_from_graph(self): + if self.v1 is not None: + self.v1.remove_constraint(self) + + if self.v2 is not None: + self.v2.remove_constraint(self) + + self.direction = Direction.NONE + + +class ScaleConstraint(BinaryConstraint): + + def __init__(self, src, scale, offset, dest, strength): + self.direction = Direction.NONE + self.scale = scale + self.offset = offset + super(ScaleConstraint, self).__init__(src, dest, strength) + + def add_to_graph(self): + super(ScaleConstraint, self).add_to_graph() + self.scale.add_constraint(self) + self.offset.add_constraint(self) + + def remove_from_graph(self): + super(ScaleConstraint, self).remove_from_graph() + + if self.scale is not None: + self.scale.remove_constraint(self) + + if self.offset is not None: + self.offset.remove_constraint(self) + + def mark_inputs(self, mark): + super(ScaleConstraint, self).mark_inputs(mark) + self.scale.mark = mark + self.offset.mark = mark + + def execute(self): + if self.direction == Direction.FORWARD: + self.v2.value = self.v1.value * self.scale.value + self.offset.value + else: + self.v1.value = ( + self.v2.value - self.offset.value) / self.scale.value + + def recalculate(self): + ihn = self.input() + out = self.output() + out.walk_strength = Strength.weakest_of( + self.strength, ihn.walk_strength) + out.stay = ihn.stay and self.scale.stay and self.offset.stay + + if out.stay: + self.execute() + + +class EqualityConstraint(BinaryConstraint): + + def execute(self): + self.output().value = self.input().value + + +class Variable(object): + + def __init__(self, name, initial_value=0): + super(Variable, self).__init__() + self.name = name + self.value = initial_value + self.constraints = OrderedCollection() + self.determined_by = None + self.mark = 0 + self.walk_strength = Strength.WEAKEST + self.stay = True + + def __repr__(self): + # To make debugging this beast from pdb easier... + return '' % ( + self.name, + self.value + ) + + def add_constraint(self, constraint): + self.constraints.append(constraint) + + def remove_constraint(self, constraint): + self.constraints.remove(constraint) + + if self.determined_by == constraint: + self.determined_by = None + + +class Planner(object): + + def __init__(self): + super(Planner, self).__init__() + self.current_mark = 0 + + def incremental_add(self, constraint): + mark = self.new_mark() + overridden = constraint.satisfy(mark) + + while overridden is not None: + overridden = overridden.satisfy(mark) + + def incremental_remove(self, constraint): + out = constraint.output() + constraint.mark_unsatisfied() + constraint.remove_from_graph() + unsatisfied = self.remove_propagate_from(out) + strength = Strength.REQUIRED + # Do-while, the Python way. + repeat = True + + while repeat: + for u in unsatisfied: + if u.strength == strength: + self.incremental_add(u) + + strength = strength.next_weaker() + + repeat = strength != Strength.WEAKEST + + def new_mark(self): + self.current_mark += 1 + return self.current_mark + + def make_plan(self, sources): + mark = self.new_mark() + plan = Plan() + todo = sources + + while len(todo): + c = todo.pop(0) + + if c.output().mark != mark and c.inputs_known(mark): + plan.add_constraint(c) + c.output().mark = mark + self.add_constraints_consuming_to(c.output(), todo) + + return plan + + def extract_plan_from_constraints(self, constraints): + sources = OrderedCollection() + + for c in constraints: + if c.is_input() and c.is_satisfied(): + sources.append(c) + + return self.make_plan(sources) + + def add_propagate(self, c, mark): + todo = OrderedCollection() + todo.append(c) + + while len(todo): + d = todo.pop(0) + + if d.output().mark == mark: + self.incremental_remove(c) + return False + + d.recalculate() + self.add_constraints_consuming_to(d.output(), todo) + + return True + + def remove_propagate_from(self, out): + out.determined_by = None + out.walk_strength = Strength.WEAKEST + out.stay = True + unsatisfied = OrderedCollection() + todo = OrderedCollection() + todo.append(out) + + while len(todo): + v = todo.pop(0) + + for c in v.constraints: + if not c.is_satisfied(): + unsatisfied.append(c) + + determining = v.determined_by + + for c in v.constraints: + if c != determining and c.is_satisfied(): + c.recalculate() + todo.append(c.output()) + + return unsatisfied + + def add_constraints_consuming_to(self, v, coll): + determining = v.determined_by + cc = v.constraints + + for c in cc: + if c != determining and c.is_satisfied(): + # I guess we're just updating a reference (``coll``)? Seems + # inconsistent with the rest of the implementation, where they + # return the lists... + coll.append(c) + + +class Plan(object): + + def __init__(self): + super(Plan, self).__init__() + self.v = OrderedCollection() + + def add_constraint(self, c): + self.v.append(c) + + def __len__(self): + return len(self.v) + + def __getitem__(self, index): + return self.v[index] + + def execute(self): + for c in self.v: + c.execute() + + +# Main + +def chain_test(n): + """ + This is the standard DeltaBlue benchmark. A long chain of equality + constraints is constructed with a stay constraint on one end. An + edit constraint is then added to the opposite end and the time is + measured for adding and removing this constraint, and extracting + and executing a constraint satisfaction plan. There are two cases. + In case 1, the added constraint is stronger than the stay + constraint and values must propagate down the entire length of the + chain. In case 2, the added constraint is weaker than the stay + constraint so it cannot be accomodated. The cost in this case is, + of course, very low. Typical situations lie somewhere between these + two extremes. + """ + global planner + planner = Planner() + prev, first, last = None, None, None + + # We need to go up to n inclusively. + for i in range(n + 1): + name = "v%s" % i + v = Variable(name) + + if prev is not None: + EqualityConstraint(prev, v, Strength.REQUIRED) + + if i == 0: + first = v + + if i == n: + last = v + + prev = v + + StayConstraint(last, Strength.STRONG_DEFAULT) + edit = EditConstraint(first, Strength.PREFERRED) + edits = OrderedCollection() + edits.append(edit) + plan = planner.extract_plan_from_constraints(edits) + + for i in range(100): + first.value = i + plan.execute() + + if last.value != i: + print("Chain test failed.") + + +def projection_test(n): + """ + This test constructs a two sets of variables related to each + other by a simple linear transformation (scale and offset). The + time is measured to change a variable on either side of the + mapping and to change the scale and offset factors. + """ + global planner + planner = Planner() + scale = Variable("scale", 10) + offset = Variable("offset", 1000) + src = None + + dests = OrderedCollection() + + for i in range(n): + src = Variable("src%s" % i, i) + dst = Variable("dst%s" % i, i) + dests.append(dst) + StayConstraint(src, Strength.NORMAL) + ScaleConstraint(src, scale, offset, dst, Strength.REQUIRED) + + change(src, 17) + + if dst.value != 1170: + print("Projection 1 failed") + + change(dst, 1050) + + if src.value != 5: + print("Projection 2 failed") + + change(scale, 5) + + for i in range(n - 1): + if dests[i].value != (i * 5 + 1000): + print("Projection 3 failed") + + change(offset, 2000) + + for i in range(n - 1): + if dests[i].value != (i * 5 + 2000): + print("Projection 4 failed") + + +def change(v, new_value): + global planner + edit = EditConstraint(v, Strength.PREFERRED) + edits = OrderedCollection() + edits.append(edit) + + plan = planner.extract_plan_from_constraints(edits) + + for i in range(10): + v.value = new_value + plan.execute() + + edit.destroy_constraint() + + +# HOORAY FOR GLOBALS... Oh wait. +# In spirit of the original, we'll keep it, but ugh. +planner = None + + +def run(): + n = 1000 + chain_test(n) + projection_test(n) diff --git a/benchmarks/interpreter/fibonacci.py b/benchmarks/interpreter/fibonacci.py new file mode 100644 index 0000000000..1ab466a77f --- /dev/null +++ b/benchmarks/interpreter/fibonacci.py @@ -0,0 +1,58 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + +# Used in the polybench harness as the default number of warmup iterations +# for this benchmark. +def warmupIterations(): + return 10 + +# Used in the polybench harness as the default number of iterations for +# this benchmark. +def iterations(): + return 30 + +# Used in the polybench harness for aggregating the iteration datapoints. +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0, + "upper-threshold": 0.3, + } + +def fibonacci(n): + if n < 1: + return 0 + if n <= 2: + return 1 + return fibonacci(n - 1) + fibonacci(n - 2) + +def run(): + number = 31 + fibo_is = 1346269 + + fibo = fibonacci(number) + + if fibo != fibo_is: + raise AssertionError(f"Unexpected result: {fibo}") + + return fibo diff --git a/benchmarks/interpreter/pyinit.py b/benchmarks/interpreter/pyinit.py new file mode 100644 index 0000000000..89f205d7f1 --- /dev/null +++ b/benchmarks/interpreter/pyinit.py @@ -0,0 +1,30 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + + +def run(): + """ + this benchmark is intentionaly left emtpy as it's sole purpose is to be + used to measure python initialization time + """ + pass diff --git a/benchmarks/interpreter/richards.py b/benchmarks/interpreter/richards.py new file mode 100644 index 0000000000..3761bb0663 --- /dev/null +++ b/benchmarks/interpreter/richards.py @@ -0,0 +1,435 @@ +# Copyright 2008-2010 Isaac Gouy +# Copyright (c) 2013, 2014, Regents of the University of California +# Copyright (c) 2018, 2021, Oracle and/or its affiliates. +# All rights reserved. +# +# Revised BSD license +# +# This is a specific instance of the Open Source Initiative (OSI) BSD license +# template http://www.opensource.org/licenses/bsd-license.php +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of "The Computer Language Benchmarks Game" nor the name of +# "The Computer Language Shootout Benchmarks" nor the name "nanobench" nor the +# name "bencher" nor the names of its contributors may be used to endorse or +# promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# based on a Java version: +# Based on original version written in BCPL by Dr Martin Richards +# in 1981 at Cambridge University Computer Laboratory, England +# and a C++ version derived from a Smalltalk version written by +# L Peter Deutsch. +# Java version: Copyright (C) 1995 Sun Microsystems, Inc. +# Translation from C++, Mario Wolczko +# Outer loop added by Alex Jacoby +from __future__ import print_function + +# Used in the polybench harness as the default number of iterations for +# this benchmark. +def iterations(): + return 60 + +# Used in the polybench harness for aggregating the iteration datapoints. +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.05, + "upper-threshold": 0.2, + } + +# Task IDs +I_IDLE = 1 +I_WORK = 2 +I_HANDLERA = 3 +I_HANDLERB = 4 +I_DEVA = 5 +I_DEVB = 6 + +# Packet types +K_DEV = 1000 +K_WORK = 1001 + +# Packet + +BUFSIZE = 4 + +BUFSIZE_RANGE = list(range(BUFSIZE)) + +class Packet(object): + def __init__(self,l,i,k): + self.link = l + self.ident = i + self.kind = k + self.datum = 0 + self.data = [0] * BUFSIZE + + def append_to(self,lst): + self.link = None + if lst is None: + return self + else: + p = lst + next = p.link + while next is not None: + p = next + next = p.link + p.link = self + return lst + +# Task Records + +class TaskRec(object): + pass + +class DeviceTaskRec(TaskRec): + def __init__(self): + self.pending = None + +class IdleTaskRec(TaskRec): + def __init__(self): + self.control = 1 + self.count = 10000 + +class HandlerTaskRec(TaskRec): + def __init__(self): + self.work_in = None + self.device_in = None + + def workInAdd(self,p): + self.work_in = p.append_to(self.work_in) + return self.work_in + + def deviceInAdd(self,p): + self.device_in = p.append_to(self.device_in) + return self.device_in + +class WorkerTaskRec(TaskRec): + def __init__(self): + self.destination = I_HANDLERA + self.count = 0 +# Task + +class TaskState(object): + def __init__(self): + self.packet_pending = True + self.task_waiting = False + self.task_holding = False + + def packetPending(self): + self.packet_pending = True + self.task_waiting = False + self.task_holding = False + return self + + def waiting(self): + self.packet_pending = False + self.task_waiting = True + self.task_holding = False + return self + + def running(self): + self.packet_pending = False + self.task_waiting = False + self.task_holding = False + return self + + def waitingWithPacket(self): + self.packet_pending = True + self.task_waiting = True + self.task_holding = False + return self + + def isPacketPending(self): + return self.packet_pending + + def isTaskWaiting(self): + return self.task_waiting + + def isTaskHolding(self): + return self.task_holding + + def isTaskHoldingOrWaiting(self): + return self.task_holding or (not self.packet_pending and self.task_waiting) + + def isWaitingWithPacket(self): + return self.packet_pending and self.task_waiting and not self.task_holding + + + + + +tracing = False +layout = 0 + +def trace(a): + global layout + layout -= 1 + if layout <= 0: + print() + layout = 50 + print(a, end=' ') + + +TASKTABSIZE = 10 + +class TaskWorkArea(object): + def __init__(self): + self.taskTab = [None] * TASKTABSIZE + + self.taskList = None + + self.holdCount = 0 + self.qpktCount = 0 + +taskWorkArea = TaskWorkArea() + +class Task(TaskState): + + + def __init__(self,i,p,w,initialState,r): + self.link = taskWorkArea.taskList + self.ident = i + self.priority = p + self.input = w + + self.packet_pending = initialState.isPacketPending() + self.task_waiting = initialState.isTaskWaiting() + self.task_holding = initialState.isTaskHolding() + + self.handle = r + + taskWorkArea.taskList = self + taskWorkArea.taskTab[i] = self + + def fn(self,pkt,r): + raise NotImplementedError + + + def addPacket(self,p,old): + if self.input is None: + self.input = p + self.packet_pending = True + if self.priority > old.priority: + return self + else: + p.append_to(self.input) + return old + + + def runTask(self): + if self.isWaitingWithPacket(): + msg = self.input + self.input = msg.link + if self.input is None: + self.running() + else: + self.packetPending() + else: + msg = None + + return self.fn(msg,self.handle) + + + def waitTask(self): + self.task_waiting = True + return self + + + def hold(self): + taskWorkArea.holdCount += 1 + self.task_holding = True + return self.link + + + def release(self,i): + t = self.findtcb(i) + t.task_holding = False + if t.priority > self.priority: + return t + else: + return self + + + def qpkt(self,pkt): + t = self.findtcb(pkt.ident) + taskWorkArea.qpktCount += 1 + pkt.link = None + pkt.ident = self.ident + return t.addPacket(pkt,self) + + + def findtcb(self,id): + t = taskWorkArea.taskTab[id] + if t is None: + raise Exception("Bad task id %d" % id) + return t + + +# DeviceTask + + +class DeviceTask(Task): + def __init__(self,i,p,w,s,r): + Task.__init__(self,i,p,w,s,r) + + def fn(self,pkt,r): + d = r + assert isinstance(d, DeviceTaskRec) + if pkt is None: + pkt = d.pending + if pkt is None: + return self.waitTask() + else: + d.pending = None + return self.qpkt(pkt) + else: + d.pending = pkt + if tracing: trace(pkt.datum) + return self.hold() + + + +class HandlerTask(Task): + def __init__(self,i,p,w,s,r): + Task.__init__(self,i,p,w,s,r) + + def fn(self,pkt,r): + h = r + assert isinstance(h, HandlerTaskRec) + if pkt is not None: + if pkt.kind == K_WORK: + h.workInAdd(pkt) + else: + h.deviceInAdd(pkt) + work = h.work_in + if work is None: + return self.waitTask() + count = work.datum + if count >= BUFSIZE: + h.work_in = work.link + return self.qpkt(work) + + dev = h.device_in + if dev is None: + return self.waitTask() + + h.device_in = dev.link + dev.datum = work.data[count] + work.datum = count + 1 + return self.qpkt(dev) + +# IdleTask + + +class IdleTask(Task): + def __init__(self,i,p,w,s,r): + Task.__init__(self,i,0,None,s,r) + + def fn(self,pkt,r): + i = r + assert isinstance(i, IdleTaskRec) + i.count -= 1 + if i.count == 0: + return self.hold() + elif i.control & 1 == 0: + i.control //= 2 + return self.release(I_DEVA) + else: + i.control = i.control // 2 ^ 0xd008 + return self.release(I_DEVB) + + +# WorkTask + + +A = ord('A') + +class WorkTask(Task): + def __init__(self,i,p,w,s,r): + Task.__init__(self,i,p,w,s,r) + + def fn(self,pkt,r): + w = r + assert isinstance(w, WorkerTaskRec) + if pkt is None: + return self.waitTask() + + if w.destination == I_HANDLERA: + dest = I_HANDLERB + else: + dest = I_HANDLERA + + w.destination = dest + pkt.ident = dest + pkt.datum = 0 + + for i in BUFSIZE_RANGE: # xrange(BUFSIZE) + w.count += 1 + if w.count > 26: + w.count = 1 + pkt.data[i] = A + w.count - 1 + + return self.qpkt(pkt) + +def schedule(): + t = taskWorkArea.taskList + while t is not None: + pkt = None + + if tracing: + print("tcb =",t.ident) + + if t.isTaskHoldingOrWaiting(): + t = t.link + else: + if tracing: trace(chr(ord("0")+t.ident)) + t = t.runTask() + +def run(): + taskWorkArea.holdCount = 0 + taskWorkArea.qpktCount = 0 + + IdleTask(I_IDLE, 1, 10000, TaskState().running(), IdleTaskRec()) + + wkq = Packet(None, 0, K_WORK) + wkq = Packet(wkq , 0, K_WORK) + WorkTask(I_WORK, 1000, wkq, TaskState().waitingWithPacket(), WorkerTaskRec()) + + wkq = Packet(None, I_DEVA, K_DEV) + wkq = Packet(wkq , I_DEVA, K_DEV) + wkq = Packet(wkq , I_DEVA, K_DEV) + HandlerTask(I_HANDLERA, 2000, wkq, TaskState().waitingWithPacket(), HandlerTaskRec()) + + wkq = Packet(None, I_DEVB, K_DEV) + wkq = Packet(wkq , I_DEVB, K_DEV) + wkq = Packet(wkq , I_DEVB, K_DEV) + HandlerTask(I_HANDLERB, 3000, wkq, TaskState().waitingWithPacket(), HandlerTaskRec()) + + wkq = None + DeviceTask(I_DEVA, 4000, wkq, TaskState().waiting(), DeviceTaskRec()) + DeviceTask(I_DEVB, 5000, wkq, TaskState().waiting(), DeviceTaskRec()) + + schedule() + + return taskWorkArea.holdCount == 9297 and taskWorkArea.qpktCount == 23246 \ No newline at end of file diff --git a/benchmarks/interpreter/sieve.py b/benchmarks/interpreter/sieve.py new file mode 100644 index 0000000000..59f27042a6 --- /dev/null +++ b/benchmarks/interpreter/sieve.py @@ -0,0 +1,56 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + +# Used in the polybench harness as the default number of iterations for +# this benchmark. +def iterations(): + return 90 + +# Used in the polybench harness for aggregating the iteration datapoints. +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.4, + } + +def run(): + number = 600000 + primes = list(range(0, number+1)) + + i = 2 + while (i**2) <= number: + if primes[i] != 0: + for j in range(2, number): + if primes[i] * j > number: + break + else: + primes[primes[i] * j] = 0 + i += 1 + + count = 0 + for c in range(2, number+1): + if primes[c] != 0: + count += 1 + + return count diff --git a/benchmarks/warmup/pyflate-fast.py b/benchmarks/warmup/pyflate-fast.py new file mode 100644 index 0000000000..cd77b70f59 --- /dev/null +++ b/benchmarks/warmup/pyflate-fast.py @@ -0,0 +1,717 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + +# This benchmark is derived from the URL below, which had the following +# copyright notice. +# +# Copyright 2006--2007-01-21 Paul Sladen +# +# You may use and distribute this code under any DFSG-compatible +# license (eg. BSD, GNU GPLv2). +# +# Stand-alone pure-Python DEFLATE (gzip) and bzip2 decoder/decompressor. +# This is probably most useful for research purposes/index building; there +# is certainly some room for improvement in the Huffman bit-matcher. +# +# With the as-written implementation, there was a known bug in BWT +# decoding to do with repeated strings. This has been worked around; +# see 'bwt_reverse()'. Correct output is produced in all test cases +# but ideally the problem would be found... +import sys +if sys.version_info[0] > 2: + xrange = range + +class BitfieldBase(object): + def __init__(self, x): + if isinstance(x,BitfieldBase): + self.f = x.f + self.bits = x.bits + self.bitfield = x.bitfield + self.count = x.bitfield + else: + self.f = x + self.bits = 0 + self.bitfield = 0x0 + self.count = 0 + def _read(self, n): + s = self.f.read(n) + if not s: + raise "Length Error" + self.count += len(s) + return s + def needbits(self, n): + while self.bits < n: + self._more() + def _mask(self, n): + return (1 << n) - 1 + def toskip(self): + return self.bits & 0x7 + def align(self): + self.readbits(self.toskip()) + def dropbits(self, n = 8): + while n >= self.bits and n > 7: + n -= self.bits + self.bits = 0 + n -= len(self.f._read(n >> 3)) << 3 + if n: + self.readbits(n) + # No return value + def dropbytes(self, n = 1): + self.dropbits(n << 3) + def tell(self): + return self.count - ((self.bits+7) >> 3), 7 - ((self.bits-1) & 0x7) + def tellbits(self): + bytes, bits = self.tell() + return (bytes << 3) + bits + +class Bitfield(BitfieldBase): + def _more(self): + c = self._read(1) + self.bitfield += ord(c) << self.bits + self.bits += 8 + def snoopbits(self, n = 8): + if n > self.bits: + self.needbits(n) + return self.bitfield & self._mask(n) + def readbits(self, n = 8): + if n > self.bits: + self.needbits(n) + r = self.bitfield & self._mask(n) + self.bits -= n + self.bitfield >>= n + return r + +class RBitfield(BitfieldBase): + def _more(self): + c = self._read(1) + self.bitfield <<= 8 + self.bitfield += ord(c) + self.bits += 8 + def snoopbits(self, n = 8): + if n > self.bits: + self.needbits(n) + return (self.bitfield >> (self.bits - n)) & self._mask(n) + def readbits(self, n = 8): + if n > self.bits: + self.needbits(n) + r = (self.bitfield >> (self.bits - n)) & self._mask(n) + self.bits -= n + self.bitfield &= ~(self._mask(n) << self.bits) + return r + +def printbits(v, n): + o = '' + for i in range(n): + if v & 1: + o = '1' + o + else: + o = '0' + o + v >>= 1 + return o + +class HuffmanLength(object): + def __init__(self, code, bits = 0): + self.code = code + self.bits = bits + self.symbol = None + def __repr__(self): + return {}.format((self.code, self.bits, self.symbol, self.reverse_symbol)) + def __cmp__(self, other): + if self.bits == other.bits: + return cmp(self.code, other.code) + else: + return cmp(self.bits, other.bits) + def __lt__(self, other): + if self.bits == other.bits: + return self.code < other.code + else: + return self.bits < other.bits + +def reverse_bits(v, n): + a = 1 << 0 + b = 1 << (n - 1) + z = 0 + for i in range(n-1, -1, -2): + z |= (v >> i) & a + z |= (v << i) & b + a <<= 1 + b >>= 1 + return z + +def reverse_bytes(v, n): + a = 0xff << 0 + b = 0xff << (n - 8) + z = 0 + for i in range(n-8, -8, -16): + z |= (v >> i) & a + z |= (v << i) & b + a <<= 8 + b >>= 8 + return z + +class HuffmanTable(object): + def __init__(self, bootstrap): + l = [] + start, bits = bootstrap[0] + for finish, endbits in bootstrap[1:]: + if bits: + for code in range(start, finish): + l.append(HuffmanLength(code, bits)) + start, bits = finish, endbits + if endbits == -1: + break + l.sort() + self.table = l + + def populate_huffman_symbols(self): + bits, symbol = -1, -1 + for x in self.table: + symbol += 1 + if x.bits != bits: + symbol <<= (x.bits - bits) + bits = x.bits + x.symbol = symbol + x.reverse_symbol = reverse_bits(symbol, bits) + #print(printbits(x.symbol, bits), printbits(x.reverse_symbol, bits)) + + def tables_by_bits(self): + d = {} + for x in self.table: + try: + d[x.bits].append(x) + except: + d[x.bits] = [x] + pass + + def min_max_bits(self): + self.min_bits, self.max_bits = 16, -1 + for x in self.table: + if x.bits < self.min_bits: self.min_bits = x.bits + if x.bits > self.max_bits: self.max_bits = x.bits + + def _find_symbol(self, bits, symbol, table): + for h in table: + if h.bits == bits and h.reverse_symbol == symbol: + #print("found, processing", h.code) + return h.code + return -1 + + def find_next_symbol(self, field, reversed = True): + cached_length = -1 + cached = None + for x in self.table: + if cached_length != x.bits: + cached = field.snoopbits(x.bits) + cached_length = x.bits + if (reversed and x.reverse_symbol == cached) or (not reversed and x.symbol == cached): + field.readbits(x.bits) + return x.code + raise "unfound symbol, even after end of table @ {}".format(field.tell()) + + for bits in range(self.min_bits, self.max_bits + 1): + #print(printbits(field.snoopbits(bits),bits)) + r = self._find_symbol(bits, field.snoopbits(bits), self.table) + if 0 <= r: + field.readbits(bits) + return r + elif bits == self.max_bits: + raise "unfound symbol, even after max_bits" + +class OrderedHuffmanTable(HuffmanTable): + def __init__(self, lengths): + l = len(lengths) + z = list(zip(range(l), lengths)) + [(l, -1)] + HuffmanTable.__init__(self, z) + +def code_length_orders(i): + return (16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15)[i] + +def distance_base(i): + return (1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577)[i] + +def length_base(i): + return (3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258)[i-257] + +def extra_distance_bits(n): + if 0 <= n <= 1: + return 0 + elif 2 <= n <= 29: + return (n >> 1) - 1 + else: + raise "illegal distance code" + +def extra_length_bits(n): + if 257 <= n <= 260 or n == 285: + return 0 + elif 261 <= n <= 284: + return ((n-257) >> 2) - 1 + else: + raise "illegal length code" + +def move_to_front(l, c): + l[:] = l[c:c+1] + l[0:c] + l[c+1:] + +def bwt_transform(L): + # Semi-inefficient way to get the character counts + F = ''.join(sorted(L)) + base = [] + for i in range(256): + base.append(F.find(chr(i))) + + pointers = [-1] * len(L) + for i, char in enumerate(L): + symbol = ord(char) + pointers[base[symbol]] = i + base[symbol] += 1 + return pointers + +def bwt_reverse(L, end): + out = [] + if len(L): + T = bwt_transform(L) + + # STRAGENESS WARNING: There was a bug somewhere here in that + # if the output of the BWT resolves to a perfect copy of N + # identical strings (think exact multiples of 255 'X' here), + # then a loop is formed. When decoded, the output string would + # be cut off after the first loop, typically '\0\0\0\0\xfb'. + # The previous loop construct was: + # + # next = T[end] + # while next != end: + # out += L[next] + # next = T[next] + # out += L[next] + # + # For the moment, I've instead replaced it with a check to see + # if there has been enough output generated. I didn't figured + # out where the off-by-one-ism is yet---that actually produced + # the cyclic loop. + + for i in xrange(len(L)): + end = T[end] + out.append(L[end]) + + return "".join(out) + +def compute_used(b): + huffman_used_map = b.readbits(16) + #print('used map', hex(huffman_used_map)) + map_mask = 1 << 15 + used = [] + while map_mask > 0: + if huffman_used_map & map_mask: + huffman_used_bitmap = b.readbits(16) + bit_mask = 1 << 15 + while bit_mask > 0: + if huffman_used_bitmap & bit_mask: + #print('hit', len(used)) + pass + used += [bool(huffman_used_bitmap & bit_mask)] + bit_mask >>= 1 + else: + used += [False] * 16 + map_mask >>= 1 + return used + +def compute_selectors_list(b, huffman_groups): + selectors_used = b.readbits(15) + #print('selectors used', selectors_used) + mtf = list(range(huffman_groups)) + selectors_list = [] + for i in range(selectors_used): + # zero-terminated bit runs (0..62) of MTF'ed huffman table + c = 0 + while b.readbits(1): + c += 1 + if c >= huffman_groups: + raise "Bzip2 chosen selector greater than number of groups (max 6)" + if c >= 0: + move_to_front(mtf, c) + #print(c, mtf) + selectors_list.append(mtf[0]) + return selectors_list + +def compute_tables(b, huffman_groups, symbols_in_use): + groups_lengths = [] + for j in range(huffman_groups): + length = start_huffman_length = b.readbits(5) + #print('start_huffman_length', start_huffman_length) + lengths = [] + for i in range(symbols_in_use): + if not 0 <= length <= 20: + raise "Bzip2 Huffman length code outside range 0..20" + while b.readbits(1): + length -= (b.readbits(1) * 2) - 1 + lengths += [length] + groups_lengths += [lengths] + #print(groups_lengths) + + tables = [] + for g in groups_lengths: + codes = OrderedHuffmanTable(g) + codes.populate_huffman_symbols() + codes.min_max_bits() + tables.append(codes) + return tables + +def decode_huffman_block(b, out): + #print('bzip2 Huffman block') + randomised = b.readbits(1) + if randomised: + raise "Bzip2 randomised support not implemented" + pointer = b.readbits(24) + #print('pointer', pointer, hex(pointer)) + used = compute_used(b) + + huffman_groups = b.readbits(3) + #print('huffman groups', huffman_groups) + if not 2 <= huffman_groups <= 6: + raise "Bzip2: Number of Huffman groups not in range 2..6" + + selectors_list = compute_selectors_list(b, huffman_groups) + symbols_in_use = sum(used) + 2 # remember RUN[AB] RLE symbols + tables = compute_tables(b, huffman_groups, symbols_in_use) + + #favourites = map(chr,range(sum(used))) + #favourites = string.join([y for x,y in map(None,used,map(chr,range(len(used)))) if x],'') + favourites = list([chr(i) for i, x in enumerate(used) if x]) + + data_start = b.tellbits() + selector_pointer = 0 + decoded = 0 + # Main Huffman loop + repeat = repeat_power = 0 + buffer = [] + t = None + while True: + decoded -= 1 + if decoded <= 0: + #print('RETABLE TIME', selectors_list[selector_pointer]) + decoded = 50 # Huffman table re-evaluate/switch length + if selector_pointer <= len(selectors_list): + t = tables[selectors_list[selector_pointer]] + selector_pointer += 1 + #print('tables changed', tables[0].table) + #print(b.tell()) + r = t.find_next_symbol(b, False) + #print('symbol', r) + if 0 <= r <= 1: + if repeat == 0: + repeat_power = 1 + #print('run', repeat) + repeat += repeat_power << r + repeat_power <<= 1 + continue + elif repeat > 0: + # Remember kids: If there is only one repeated + # real symbol, it is encoded with *zero* Huffman + # bits and not output... so buffer[-1] doesn't work. + #print('runfinal', repeat) + buffer.append(favourites[0] * repeat) + repeat = 0 + if r == symbols_in_use - 1: + #print('finished {} .. {}'.format(buffer[:10], buffer[-10:]), 'len', len(buffer)) + break + else: + o = favourites[r-1] + #print('pre {}'.format(favourites)) + move_to_front(favourites, r-1) + #print('post {}'.format(favourites)) + #print('output {}.format(o)) + buffer.append(o) + pass + #print('huffman {}'.format(buffer), pointer, len(buffer)) + #nearly_there = bwt_reverse(buffer, len(buffer)-pointer-1) + nt = nearly_there = bwt_reverse("".join(buffer), pointer) + #print('nearly there {}'.format(nearly_there)) + i = 0 + # Pointless/irritating run-length encoding step + while i < len(nearly_there): + #print('RLE decode {}'.format(nt[i:])) + if i < len(nearly_there) - 4 and nt[i] == nt[i+1] == nt[i+2] == nt[i+3]: + out.append(nearly_there[i] * (ord(nearly_there[i+4]) + 4)) + i += 5 + else: + out.append(nearly_there[i]) + i += 1 + #print('done {} .. {}'.format(done[:10], done[-10:]), 'len', len(done)) + + #raise "Bip2 block support not implemented" + +# Sixteen bits of magic have been removed by the time we start decoding +def bzip2_main(input): + b = RBitfield(input) + + method = b.readbits(8) + if method != ord('h'): + raise "Unknown (not type 'h'uffman Bzip2) compression method" + + blocksize = b.readbits(8) + if ord('1') <= blocksize <= ord('9'): + blocksize = blocksize - ord('0') + else: + raise "Unknown (not size '0'-'9') Bzip2 blocksize" + + out = [] + while True: + #header_start = b.tellbits() + blocktype = b.readbits(48) + crc = b.readbits(32) + #print(hex(blocktype)) + #print(hex(crc)) + if blocktype == 0x314159265359: # (pi) + decode_huffman_block(b, out) + elif blocktype == 0x177245385090: # sqrt(pi) + #print('bzip2 end-of-stream block') + b.align() + break + else: + raise "Illegal Bzip2 blocktype" + #print(len(out), set([len(s) for s in out])) + return ''.join(out) + +# Sixteen bits of magic have been removed by the time we start decoding +def gzip_main(field): + b = Bitfield(field) + method = b.readbits(8) + if method != 8: + raise "Unknown (not type eight DEFLATE) compression method" + + # Use flags, drop modification time, extra flags and OS creator type. + flags = b.readbits(8) + #print('flags', hex(flags)) + mtime = b.readbits(32) + #print('mtime', hex(mtime)) + extra_flags = b.readbits(8) + #print('extra_flags', hex(extra_flags)) + os_type = b.readbits(8) + #print('os_type', hex(os_type)) + + if flags & 0x04: # structured GZ_FEXTRA miscellaneous data + xlen = b.readbits(16) + b.dropbytes(xlen) + while flags & 0x08: # original GZ_FNAME filename + if not b.readbits(8): + break + while flags & 0x10: # human readable GZ_FCOMMENT + if not b.readbits(8): + break + if flags & 0x02: # header-only GZ_FHCRC checksum + b.readbits(16) + + #print("gzip header skip", b.tell()) + out = [] + + #print('header 0 count 0 bits', b.tellbits()) + + while True: + header_start = b.tell() + bheader_start = b.tellbits() + #print('new block at', b.tell()) + lastbit = b.readbits(1) + #print("last bit", hex(lastbit)) + blocktype = b.readbits(2) + #print("deflate-blocktype", blocktype, 'beginning at', header_start) + + #print('raw block data at', b.tell()) + if blocktype == 0: + b.align() + length = b.readbits(16) + if length & b.readbits(16): + raise "stored block lengths do not match each other" + #print("stored block of length", length) + #print('raw data at', b.tell(), 'bits', b.tellbits() - bheader_start) + #print('header 0 count 0 bits', b.tellbits() - bheader_start) + for i in range(length): + out.append(chr(b.readbits(8))) + #print('linear', b.tell()[0], 'count', length, 'bits', b.tellbits() - bheader_start) + + elif blocktype == 1 or blocktype == 2: # Huffman + main_literals, main_distances = None, None + + if blocktype == 1: # Static Huffman + static_huffman_bootstrap = [(0, 8), (144, 9), (256, 7), (280, 8), (288, -1)] + static_huffman_lengths_bootstrap = [(0, 5), (32, -1)] + main_literals = HuffmanTable(static_huffman_bootstrap) + main_distances = HuffmanTable(static_huffman_lengths_bootstrap) + + elif blocktype == 2: # Dynamic Huffman + literals = b.readbits(5) + 257 + distances = b.readbits(5) + 1 + code_lengths_length = b.readbits(4) + 4 + + l = [0] * 19 + for i in range(code_lengths_length): + l[code_length_orders(i)] = b.readbits(3) + + dynamic_codes = OrderedHuffmanTable(l) + dynamic_codes.populate_huffman_symbols() + dynamic_codes.min_max_bits() + + # Decode the code_lengths for both tables at once, + # then split the list later + + code_lengths = [] + n = 0 + while n < (literals + distances): + r = dynamic_codes.find_next_symbol(b) + if 0 <= r <= 15: # literal bitlength for this code + count = 1 + what = r + elif r == 16: # repeat last code + count = 3 + b.readbits(2) + # Is this supposed to default to '0' if in the zeroth position? + what = code_lengths[-1] + elif r == 17: # repeat zero + count = 3 + b.readbits(3) + what = 0 + elif r == 18: # repeat zero lots + count = 11 + b.readbits(7) + what = 0 + else: + raise "next code length is outside of the range 0 <= r <= 18" + code_lengths += [what] * count + n += count + + main_literals = OrderedHuffmanTable(code_lengths[:literals]) + main_distances = OrderedHuffmanTable(code_lengths[literals:]) + + # Common path for both Static and Dynamic Huffman decode now + + data_start = b.tell() + #print('raw data at', data_start, 'bits', b.tellbits() - bheader_start) + #print('header 0 count 0 bits', b.tellbits() - bheader_start) + + main_literals.populate_huffman_symbols() + main_distances.populate_huffman_symbols() + + main_literals.min_max_bits() + main_distances.min_max_bits() + + literal_count = 0 + literal_start = 0 + + while True: + lz_start = b.tellbits() + r = main_literals.find_next_symbol(b) + if 0 <= r <= 255: + if literal_count == 0: + literal_start = lz_start + literal_count += 1 + #print('found literal {}'.format(chr(r))) + out.append(chr(r)) + elif r == 256: + if literal_count > 0: + #print('add 0 count', literal_count, 'bits', lz_start-literal_start, 'dat) {}'.format(out[-literal_count:])) + literal_count = 0 + #print('eos 0 count 0 bits', b.tellbits() - lz_start) + #print('end of Huffman block encountered') + break + elif 257 <= r <= 285: # dictionary lookup + if literal_count > 0: + #print('add 0 count', literal_count, 'bits', lz_start-literal_start, 'data {}'.format(out[-literal_count:])) + literal_count = 0 + length_extra = b.readbits(extra_length_bits(r)) + length = length_base(r) + length_extra + #print('dictionary lookup: length', length,) + + r1 = main_distances.find_next_symbol(b) + if 0 <= r1 <= 29: + distance = distance_base(r1) + b.readbits(extra_distance_bits(r1)) + cached_length = length + while length > distance: + out += out[-distance:] + length -= distance + if length == distance: + out += out[-distance:] + else: + out += out[-distance:length-distance] + #print('copy', -distance, 'count', cached_length, 'bits', b.tellbits() - lz_start, 'data {}'.format(out[-cached_length:])) + elif 30 <= r1 <= 31: + raise "illegal unused distance symbol in use @ {}".format(b.tell()) + elif 286 <= r <= 287: + raise "illegal unused literal/length symbol in use @ {}".format(b.tell()) + elif blocktype == 3: + raise "illegal unused blocktype in use @ {}".format(b.tell()) + + if lastbit: + #print("this was the last block, time to leave", b.tell()) + break + + footer_start = b.tell() + bfooter_start = b.tellbits() + b.align() + crc = b.readbits(32) + final_length = b.readbits(32) + #print(len(out)) + next_unused = b.tell() + #print('deflate-end-of-stream', 5, 'beginning at', footer_start, 'raw data at', next_unused, 'bits', b.tellbits() - bfooter_start) + #print('deflate-end-of-stream') + #print('crc', hex(crc), 'final length', final_length) + #print('header 0 count 0 bits', b.tellbits()-bfooter_start) + + return "".join(out) + +import sys, os + +def _main(): + filename = os.path.join(os.path.dirname(__file__), "graalpython-pyflate-benchmark-resource.tar.gz") + input = open(filename, 'rb') + field = RBitfield(input) + + magic = field.readbits(16) + if magic == 0x1f8b: # GZip + out = gzip_main(field) + elif magic == 0x425a: # BZip2 + out = bzip2_main(field) + else: + raise "Unknown file magic "+hex(magic)+", not a gzip/bzip2 file" + + from hashlib import md5 + # print(md5(out.encode('utf-8')).hexdigest()) + assert md5(out.encode('utf-8')).hexdigest() == "0d8772135b981f5cfd9acbf23ba643d7" + input.close() + +run = _main + + +def main(warmup=20, iterations=30): + import time + for i in range(warmup): + t1 = time.time() + _main() + t2 = time.time() - t1 + print("Warmup", i, ":", t2 * 1000, "ms") + for i in range(iterations): + t1 = time.time() + _main() + t2 = time.time() - t1 + print("Iteration", i, ":", t2 * 1000, "ms") + + +if __name__ == "__main__" and sys.implementation.name != "graalpy": + print(f"Running {os.path.basename(__file__)}") + times = main(20, 30) + for idx, time in enumerate(times): + print("Iteration", idx, ":", time, "ms") diff --git a/benchmarks/warmup/raytrace.py b/benchmarks/warmup/raytrace.py new file mode 100644 index 0000000000..c69fe3f6d6 --- /dev/null +++ b/benchmarks/warmup/raytrace.py @@ -0,0 +1,417 @@ +# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. + +# This benchmark is derived from the URL below, which had the following +# copyright notice and was originally under MIT. +# +# Copyright Callum and Tony Garnock-Jones, 2008. +# This file contains definitions for a simple raytracer. +# This file may be freely redistributed under the MIT license. + +import math + +EPSILON = 0.00001 +INF = 1.0e9 + +class Vector(object): + def __init__(self, initx, inity, initz): + self.x = initx + self.y = inity + self.z = initz + + def __str__(self): + return '(%s,%s,%s)' % (self.x, self.y, self.z) + + def __repr__(self): + return 'Vector(%s,%s,%s)' % (self.x, self.y, self.z) + + def magnitude(self): + return math.sqrt(self.dot(self)) + + def __add__(self, other): + return Vector(self.x + other.x, self.y + other.y, self.z + other.z) + + def __sub__(self, other): + return Vector(self.x - other.x, self.y - other.y, self.z - other.z) + + def scale(self, factor): + return Vector(factor * self.x, factor * self.y, factor * self.z) + + def dot(self, other): + return (self.x * other.x) + (self.y * other.y) + (self.z * other.z) + + def cross(self, other): + return Vector(self.y * other.z - self.z * other.y, + self.z * other.x - self.x * other.z, + self.x * other.y - self.y * other.x) + + def normalized(self): + return self.scale(1.0 / self.magnitude()) + + def negated(self): + return self.scale(-1) + + def __eq__(self, other): + return (self.x == other.x) and (self.y == other.y) and (self.z == other.z) + + def isVector(self): + return True + + def isPoint(self): + return False + + def reflectThrough(self, normal): + d = normal.scale(self.dot(normal)) + return self - d.scale(2) + +VZERO = Vector(0,0,0) +VRIGHT = Vector(1,0,0) +VUP = Vector(0,1,0) +VOUT = Vector(0,0,1) + +if not (VRIGHT.reflectThrough(VUP) == VRIGHT): + print(1/0) +if not (Vector(-1,-1,0).reflectThrough(VUP) == Vector(-1,1,0)): + print(1/0) + +class Point(object): + def __init__(self, initx, inity, initz): + self.x = initx + self.y = inity + self.z = initz + + def __str__(self): + return '(%s,%s,%s)' % (self.x, self.y, self.z) + + def __repr__(self): + return 'Point(%s,%s,%s)' % (self.x, self.y, self.z) + + def __add__(self, other): + return Point(self.x + other.x, self.y + other.y, self.z + other.z) + + def __sub__(self, other): + return Vector(self.x - other.x, self.y - other.y, self.z - other.z) + + def isVector(self): + return False + + def isPoint(self): + return True + +class Sphere(object): + def __init__(self, centre, radius): + self.centre = centre + self.radius = radius + + def __repr__(self): + return 'Sphere(%s,%s)' % (repr(self.centre), self.radius) + + def intersectionTime(self, ray): + cp = self.centre - ray.point + v = cp.dot(ray.vector) + discriminant = (self.radius * self.radius) - (cp.dot(cp) - v*v) + if discriminant < 0: + return INF + 1 + else: + return v - math.sqrt(discriminant) + + def normalAt(self, p): + return (p - self.centre).normalized() + +class Halfspace(object): + def __init__(self, point, normal): + self.point = point + self.normal = normal.normalized() + + def __repr__(self): + return 'Halfspace(%s,%s)' % (repr(self.point), repr(self.normal)) + + def intersectionTime(self, ray): + v = ray.vector.dot(self.normal) + if v: + return 1 / -v + else: + return INF + 1 + + def normalAt(self, p): + return self.normal + +class Ray(object): + def __init__(self, point, vector): + self.point = point + self.vector = vector.normalized() + + def __repr__(self): + return 'Ray(%s,%s)' % (repr(self.point), repr(self.vector)) + + def pointAtTime(self, t): + return self.point + self.vector.scale(t) + +PZERO = Point(0,0,0) + +a = Vector(3,4,12) +b = Vector(1,1,1) + +class PpmCanvas(object): + def __init__(self, width, height, filenameBase): + self.bytes = [0] * (width * height * 3) + for i in range(width * height): + self.bytes[i * 3 + 2] = 255 + self.width = width + self.height = height + self.filenameBase = filenameBase + + def plot(self, x, y, r, g, b): + i = ((self.height - y - 1) * self.width + x) * 3 + self.bytes[i ] = max(0, min(255, int(r * 255))) + self.bytes[i+1] = max(0, min(255, int(g * 255))) + self.bytes[i+2] = max(0, min(255, int(b * 255))) + + def save(self): + with open(self.filenameBase + '.ppm', 'wb') as f: + f.write('P6 %d %d 255\n' % (self.width, self.height)) + l = [] + for c in self.bytes: + l.append(chr(c)) + f.write(''.join(l)) + +def firstIntersection(intersections): + result = intersections[0][0], INF+1, intersections[0][2] + for i in intersections: + candidateT = i[1] + if candidateT < INF and candidateT > -EPSILON: + if result[1] > INF or candidateT < result[1]: + result = i + return result + +class Scene(object): + def __init__(self): + self.objects = [] + self.lightPoints = [] + self.position = Point(0, 1.8, 10) + self.lookingAt = PZERO + self.fieldOfView = 45 + self.recursionDepth = 0 + + def lookAt(self, p): + self.lookingAt = p + + def addObject(self, on, oi, sc): + self.objects.append((on, oi, sc)) + + def addLight(self, p): + self.lightPoints.append(p) + + def render(self, canvas): + #print 'Computing field of view' + fovRadians = math.pi * (self.fieldOfView / 2.0) / 180.0 + halfWidth = math.tan(fovRadians) + halfHeight = 0.75 * halfWidth + width = halfWidth * 2 + height = halfHeight * 2 + pixelWidth = width / (canvas.width - 1) + pixelHeight = height / (canvas.height - 1) + + eye = Ray(self.position, self.lookingAt - self.position) + vpRight = eye.vector.cross(VUP).normalized() + vpUp = vpRight.cross(eye.vector).normalized() + + #print 'Looping over pixels' + previousfraction = 0.0 + for y in range(canvas.height): + currentfraction = 1.0 * y / canvas.height + if currentfraction - previousfraction > 0.05: + # print('%d%% complete' % int(currentfraction * 100)) + previousfraction = currentfraction + for x in range(canvas.width): + xcomp = vpRight.scale(x * pixelWidth - halfWidth) + ycomp = vpUp.scale(y * pixelHeight - halfHeight) + ray = Ray(eye.point, eye.vector + xcomp + ycomp) + colour = self.rayColour(ray) + canvas.plot(x,y,colour[0], colour[1], colour[2]) + + # print('Complete.') + # canvas.save() + + def rayColour(self, ray): + if self.recursionDepth > 3: + return (0.0,0.0,0.0) + + self.recursionDepth = self.recursionDepth + 1 + intersections = [] + for on, oi, sc in self.objects: + intersections.append((on, oi(ray), sc)) + # intersections = [(on, oi(ray), sc) for (on, oi, sc) in self.objects] + i = firstIntersection(intersections) + if i[1] > INF: + self.recursionDepth = self.recursionDepth - 1 + return (0.0,0.0,0.0) ## the background colour + else: + (o, t, s) = i + p = ray.pointAtTime(t) + r = s(self, ray, p, o(p)) + self.recursionDepth = self.recursionDepth - 1 + return r + + def _lightIsVisible(self, l, p): + for (on, oi, sc) in self.objects: + t = oi(Ray(p,l - p)) + if t < INF and t > EPSILON: + return False + return True + + def visibleLights(self, p): + result = [] + for l in self.lightPoints: + if self._lightIsVisible(l, p): + result.append(l) + return result + +def addColours(a, scale, b): + return (a[0] + scale * b[0], + a[1] + scale * b[1], + a[2] + scale * b[2]) + +class SimpleSurface(object): + def __init__(self, baseColour): + self.baseColour = baseColour + self.specularCoefficient = 0.2 + self.lambertCoefficient = 0.6 + self.ambientCoefficient = 1.0 - self.specularCoefficient - self.lambertCoefficient + + def baseColourAt(self, p): + return self.baseColour + + def colourAt(self, scene, ray, p, normal): + b = self.baseColourAt(p) + + c = (0.0, 0.0, 0.0) + if self.specularCoefficient > 0: + reflectedRay = Ray(p, ray.vector.reflectThrough(normal)) + #print p, normal, ray.vector, reflectedRay.vector + reflectedColour = scene.rayColour(reflectedRay) + c = addColours(c, self.specularCoefficient, reflectedColour) + + if self.lambertCoefficient > 0: + lambertAmount = 0.0 + for lightPoint in scene.visibleLights(p): + contribution = (lightPoint - p).normalized().dot(normal) + if contribution > 0: + lambertAmount = lambertAmount + contribution + lambertAmount = min(1,lambertAmount) + c = addColours(c, self.lambertCoefficient * lambertAmount, b) + + if self.ambientCoefficient > 0: + c = addColours(c, self.ambientCoefficient, b) + + return c + +class CheckerboardSurface(object): + def __init__(self): + self.baseColour = (1.0, 1.0, 1.0) + self.specularCoefficient = 0.2 + self.lambertCoefficient = 0.6 + self.ambientCoefficient = 1.0 - self.specularCoefficient - self.lambertCoefficient + self.otherColour = (0.0, 0.0, 0.0) + self.checkSize = 1 + + def baseColourAt(self, p): + v = p - PZERO + v.scale(1.0 / self.checkSize) + if (int(abs(v.x) + 0.5) + \ + int(abs(v.y) + 0.5) + \ + int(abs(v.z) + 0.5)) \ + % 2: + return self.otherColour + else: + return self.baseColour + + def colourAt(self, scene, ray, p, normal): + b = self.baseColourAt(p) + + c = (0.0,0.0,0.0) + if self.specularCoefficient > 0: + reflectedRay = Ray(p, ray.vector.reflectThrough(normal)) + #print p, normal, ray.vector, reflectedRay.vector + reflectedColour = scene.rayColour(reflectedRay) + c = addColours(c, self.specularCoefficient, reflectedColour) + + if self.lambertCoefficient > 0: + lambertAmount = 0.0 + for lightPoint in scene.visibleLights(p): + contribution = (lightPoint - p).normalized().dot(normal) + if contribution > 0: + lambertAmount = lambertAmount + contribution + lambertAmount = min(1,lambertAmount) + c = addColours(c, self.lambertCoefficient * lambertAmount, b) + + if self.ambientCoefficient > 0: + c = addColours(c, self.ambientCoefficient, b) + + return c + +def _main(): + Canvas = PpmCanvas + # c = Canvas(4,2,'test_raytrace_tiny') + # c = Canvas(80,60,'test_raytrace_small') + # c = Canvas(160,120,'test_raytrace') + c = Canvas(320,240,'test_raytrace') + # c = Canvas(640,480,'test_raytrace_big') + s = Scene() + s.addLight(Point(30, 30, 10)) + s.addLight(Point(-10, 100, 30)) + s.lookAt(Point(0, 2, 0)) + + obj = Sphere(Point(1,3,-10), 2) + surf = SimpleSurface((1.0,1.0,0.0)) + s.addObject(obj.normalAt, obj.intersectionTime, surf.colourAt) + for y in range(6): + obj = Sphere(Point(-3 - y * 0.4, 2.3, -5), 0.4) + surf = SimpleSurface((y / 6.0, 1 - y / 6.0, 0.5)) + s.addObject(obj.normalAt, obj.intersectionTime, surf.colourAt) + obj = Halfspace(Point(0,0,0), VUP) + surf = CheckerboardSurface() + s.addObject(obj.normalAt, obj.intersectionTime, surf.colourAt) + s.render(c) + +run = _main + + +def main(warmup, iterations): + import time + for i in range(warmup): + t1 = time.time() + _main() + t2 = time.time() - t1 + print("Warmup", i, ":", t2 * 1000, "ms") + for i in range(iterations): + t1 = time.time() + _main() + t2 = time.time() - t1 + print("Iteration", i, ":", t2 * 1000, "ms") + + +import os, sys +if __name__ == "__main__" and sys.implementation.name != "graalpy": + print(f"Running {os.path.basename(__file__)}") + main(20, 30) diff --git a/bisect-benchmark.ini b/bisect-benchmark.ini index c118098366..fc01ba2188 100644 --- a/bisect-benchmark.ini +++ b/bisect-benchmark.ini @@ -3,7 +3,7 @@ # Usage: # - Create a temporary branch based on the main branch (or the bad commit) # - Fill in this configuration file, preferably using the automated script -# graal-enterprise/graalpython-enterprise/scripts/create-bisect-config +# scripts/create_bisect_config.py # - Commit and push the file # - The push command output should give you a link to create a PR. Open it, but # don't create a PR. Instead, you should execute the job on your commit using diff --git a/ci.jsonnet b/ci.jsonnet index 19f1d5054d..186acf8b51 100644 --- a/ci.jsonnet +++ b/ci.jsonnet @@ -5,8 +5,8 @@ (import "ci/python-gate.libsonnet") + (import "ci/python-bench.libsonnet") + { - overlay: "a8df46e16d6fcae69e9a7c42c632131fdf6e043e", - specVersion: "6", + overlay: "40bd8048e1a6ba45494605955ffe748ae4db20be", + specVersion: "8", // Until buildbot issues around CI tiers are resolved, we cannot use them // tierConfig: self.tierConfig, @@ -17,10 +17,11 @@ RUBYGEMS_MIRROR: "", JEKYLL_THEME_GIT: "", WEBSITE_GIT: "", - STAGING_DEPLOY_CMD: [], + STAGING_DEPLOY_CMD: [["echo", "1"]], GRAAL_ENTERPRISE_GIT: "", CI_OVERLAYS_GIT: "", BENCHMARK_CONFIG_GIT: "", + NUMPY_REPO_GIT: "", PANDAS_REPO_GIT: "", PIP_EXTRA_INDEX_URL: "", WATCHDOG_GIT: "", @@ -30,7 +31,9 @@ npm_config_registry: "", RODINIA_DATASET_ZIP: "", BUILDBOT_COMMIT_SERVICE: "", + INTERNET_ACCESS_ENV: {}, }, + codeowners_builds: [], local run_spec = import "ci/graal/ci/ci_common/run-spec.libsonnet", local utils = import "ci/utils.libsonnet", @@ -74,49 +77,75 @@ local watchdog = self.watchdog, local bench_task(bench=null, benchmarks=BENCHMARKS) = super.bench_task(bench=bench, benchmarks=benchmarks), local bisect_bench_task = self.bisect_bench_task, - - local bytecode_dsl_gate(name) = task_spec({ + local internet_access_env = task_spec({ + environment +: $.overlay_imports.INTERNET_ACCESS_ENV, + }), + local oracledb_free_image = "container-registry.oracle.com/database/free:23.26.0.0", + local oracledb_extra_index_urls = std.join(" ", [ + "https://ol-graal.oraclecorp.com/mt_data/graalpy-25.0-repository/", + "https://artifactory.oci.oraclecorp.com/api/pypi/graalpy-wheels-internal-patches-dev-pypi-local/simple", + $.overlay_imports.PIP_EXTRA_INDEX_URL, + ]), + local oracledb_bench_env = task_spec({ + cacheVenv: false, + capabilities +: ["pinp"], environment +: { - BYTECODE_DSL_INTERPRETER: "true" + GRAALPY_ORACLEDB_QUIET_SECONDS: "60", + GRAALPY_ORACLEDB_WAIT_TIMEOUT: "600", + PYO_TEST_ADMIN_PASSWORD: "graalpy", + PYO_TEST_ADMIN_USER: "SYSTEM", + PYO_TEST_CONNECT_STRING: "127.0.0.1:1521/FREEPDB1", + PIP_EXTRA_INDEX_URL: oracledb_extra_index_urls, + PIP_ONLY_BINARY: ":all:", + }, + setup: [ + [ + "podman", "run", + "--detach", + "--replace", + "--name", "graalpy-oracledb", + "-p", "1521:1521", + "-e", "ORACLE_PWD=graalpy", + oracledb_free_image, + ], + ] + super.setup, + teardown +: [ + ["podman", "rm", "--force", "graalpy-oracledb"], + ], + evaluate_late +:: { + z_oracledb_podman: function(builder) { + docker: { + image: "buildslave_ol8_podman_rootless", + mount_modules: true, + }, + }, }, + }), + + local native_debug_build_env = task_spec({ + environment +: { + GRAALPY_NATIVE_DEBUG_BUILD: "true" + }, + }), + local native_debug_build_gate(name) = native_debug_build_env + task_spec({ tags :: name, }), - local bytecode_dsl_bench = task_spec({ + + // Manual interpreter variants (DSL disabled) + local manual_interpreter_env = task_spec({ environment +: { - BYTECODE_DSL_INTERPRETER: "true" + BYTECODE_DSL_INTERPRETER: "false" }, - name_suffix +:: ["bytecode-dsl"], }), - - // ----------------------------------------------------------------------------------------------------------------- - // - // extra wheel builder configs. - // - // these are definitions to build wheels for releases which aren't build as - // part of the normal (MCD) wheel builder infrastructure. the urls to the - // release binaries and which wheels to build are just updated manually - // here as needed. Wheels in particular simply have to be tested (at least - // superficially) by someone and then be added to the list. - // - // ----------------------------------------------------------------------------------------------------------------- - local WHEELS_COMMON = [ - "numpy", - "httptools", - "kiwisolver", - "psutil", - "ujson", - "xxhash", - ], - local GPY_RELEASE = { - windows: { - url: $.overlay_imports.RELEASES_BASE_URL + "python-native-standalone-svm-svmee-java23-windows-amd64/24.1.1/python-native-standalone-svm-svmee-java23-windows-amd64-24.1.1-signed.zip", - wheels: WHEELS_COMMON, - }, - darwin: { - url: $.overlay_imports.RELEASES_BASE_URL + "python-native-standalone-svm-svmee-java23-darwin-aarch64/24.1.1/python-native-standalone-svm-svmee-java23-darwin-aarch64-24.1.1-signed.tar.gz", - wheels: WHEELS_COMMON, - }, - }, + local manual_interpreter_gate(name) = manual_interpreter_env + task_spec({ + tags :: name, + }), + local manual_interpreter_bench = manual_interpreter_env + task_spec({ + name_suffix +:: ["manual-interpreter"], + }), + local with_compiler = task_spec({ + dynamic_imports +:: ["/compiler"], + }), // ----------------------------------------------------------------------------------------------------------------- // @@ -126,42 +155,34 @@ local GPY_JVM21_STANDALONE = "graalpy-jvm21-standalone", local GPY_JVM_STANDALONE = "graalpy-jvm-standalone", local GPY_NATIVE_STANDALONE = "graalpy-native-standalone", - local GPY_NATIVE_BYTECODE_DSL_STANDALONE = "graalpy-native-bc-dsl-standalone", local GPYEE_JVM_STANDALONE = "graalpy-ee-jvm-standalone", local GPYEE_NATIVE_STANDALONE = "graalpy-ee-native-standalone", local GRAAL_JDK_LATEST = "graal-jdk-latest", local TAGGED_UNITTESTS_SPLIT = 8, local COVERAGE_SPLIT = 3, + local RETAGGER_SPLIT = 16, // ----------------------------------------------------------------------------------------------------------------- // gates // ----------------------------------------------------------------------------------------------------------------- local gate_task_dict = { "python-unittest": gpgate + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : daily + t("01:00:00") + provide(GPY_JVM21_STANDALONE), - "linux:aarch64:jdk21" : daily + t("02:00:00") + provide(GPY_JVM21_STANDALONE), - "darwin:aarch64:jdk21" : daily + t("01:00:00") + provide(GPY_JVM21_STANDALONE), - "windows:amd64:jdk21" : daily + t("01:30:00") + provide(GPY_JVM21_STANDALONE), "linux:amd64:jdk-latest" : tier2 + require(GPY_JVM_STANDALONE), "linux:aarch64:jdk-latest" : tier3 + provide(GPY_JVM_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("01:30:00") + daily + provide(GPY_JVM_STANDALONE), "darwin:aarch64:jdk-latest" : tier3 + provide(GPY_JVM_STANDALONE), "windows:amd64:jdk-latest" : tier3 + provide(GPY_JVM_STANDALONE), }), - "python-unittest-bytecode-dsl": gpgate + platform_spec(no_jobs) + bytecode_dsl_gate("python-unittest") + platform_spec({ - "linux:amd64:jdk21" : daily + t("01:00:00"), - "linux:aarch64:jdk21" : daily + t("01:00:00"), - "darwin:aarch64:jdk21" : daily + t("01:00:00"), + "python-unittest-native-debug-build": gpgate + platform_spec(no_jobs) + native_debug_build_gate("python-unittest") + platform_spec({ + "linux:amd64:jdk-latest" : tier3, }), - "python-unittest-multi-context": gpgate + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : daily + t("01:00:00") + require(GPY_JVM21_STANDALONE), - "linux:aarch64:jdk21" : daily + t("01:30:00") + require(GPY_JVM21_STANDALONE), - "darwin:aarch64:jdk21" : daily + t("01:00:00") + require(GPY_JVM21_STANDALONE), - "windows:amd64:jdk21" : daily + t("02:00:00"), - "linux:amd64:jdk-latest" : tier2 + require(GPY_JVM_STANDALONE), - "linux:aarch64:jdk-latest" : daily + t("01:30:00") + require(GPY_JVM_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("01:00:00") + require(GPY_JVM_STANDALONE), - "darwin:aarch64:jdk-latest" : daily + t("01:00:00") + require(GPY_JVM_STANDALONE), + "python-unittest-manual-interpreter": gpgate + platform_spec(no_jobs) + manual_interpreter_gate("python-unittest") + platform_spec({ + "linux:amd64:jdk-latest" : daily + t("01:00:00"), + "linux:aarch64:jdk-latest" : daily + t("01:00:00"), + "darwin:aarch64:jdk-latest" : daily + t("01:00:00"), + }), + "python-unittest-multi-context": gpgate + require(GPY_JVM_STANDALONE) + platform_spec(no_jobs) + platform_spec({ + "linux:amd64:jdk-latest" : tier3, + "linux:aarch64:jdk-latest" : daily + t("02:00:00"), "windows:amd64:jdk-latest" : daily + t("01:30:00"), }), "python-unittest-jython": gpgate + platform_spec(no_jobs) + platform_spec({ @@ -170,7 +191,6 @@ "darwin:aarch64:jdk21" : daily + t("00:30:00") + require(GPY_JVM21_STANDALONE), "linux:amd64:jdk-latest" : tier2 + require(GPY_JVM_STANDALONE), "linux:aarch64:jdk-latest" : daily + t("00:30:00") + require(GPY_JVM_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("00:30:00") + require(GPY_JVM_STANDALONE), "darwin:aarch64:jdk-latest" : daily + t("00:30:00") + require(GPY_JVM_STANDALONE), }), "python-unittest-hpy": gpgate + require(GPY_NATIVE_STANDALONE) + platform_spec(no_jobs) + platform_spec({ @@ -179,18 +199,7 @@ "python-unittest-arrow-storage": gpgate + require(GPY_JVM_STANDALONE) + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier2, }), - "python-unittest-posix": gpgate + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk-latest" : tier2 + require(GPY_JVM_STANDALONE), - "linux:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("01:30:00") + require(GPY_JVM_STANDALONE), - "darwin:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE), - }), "python-unittest-standalone": gpgate_maven + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : daily + t("02:00:00") + require(GPY_JVM21_STANDALONE), - "linux:aarch64:jdk21" : daily + t("02:00:00") + require(GPY_JVM21_STANDALONE), - "darwin:aarch64:jdk21" : daily + t("02:00:00") + require(GPY_JVM21_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("02:00:00") + require(GPY_JVM_STANDALONE) + require(GRAAL_JDK_LATEST), - "windows:amd64:jdk21" : daily + t("02:00:00") + require(GPY_JVM21_STANDALONE) + batches(2), "linux:amd64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE) + require(GRAAL_JDK_LATEST), "linux:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE) + require(GRAAL_JDK_LATEST), "darwin:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE) + require(GRAAL_JDK_LATEST), @@ -201,14 +210,13 @@ "linux:aarch64:jdk21" : daily + t("01:30:00"), "darwin:aarch64:jdk21" : daily + t("01:30:00"), "windows:amd64:jdk21" : daily + t("01:00:00"), - "linux:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), - "linux:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), - "darwin:amd64:jdk-latest" : daily + t("01:30:00"), - "darwin:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), - "windows:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), + "linux:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST) + with_compiler, + "linux:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST) + with_compiler, + "darwin:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST) + with_compiler, + "windows:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST) + with_compiler, }), - "python-junit-bytecode-dsl": gpgate + platform_spec(no_jobs) + bytecode_dsl_gate("python-junit") + platform_spec({ - "linux:amd64:jdk21" : tier3 + require(GRAAL_JDK_LATEST), + "python-junit-manual-interpreter": gpgate + platform_spec(no_jobs) + manual_interpreter_gate("python-junit") + platform_spec({ + "linux:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST) + with_compiler, }), "python-junit-maven": gpgate_maven + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk21" : daily + t("00:30:00"), @@ -217,7 +225,6 @@ "windows:amd64:jdk21" : daily + t("01:30:00"), "linux:amd64:jdk-latest" : tier3 + provide(GRAAL_JDK_LATEST), "linux:aarch64:jdk-latest" : tier3 + provide(GRAAL_JDK_LATEST), - "darwin:amd64:jdk-latest" : daily + t("01:30:00") + provide(GRAAL_JDK_LATEST), "darwin:aarch64:jdk-latest" : tier3 + provide(GRAAL_JDK_LATEST), "windows:amd64:jdk-latest" : tier3 + provide(GRAAL_JDK_LATEST), }), @@ -229,55 +236,62 @@ }), "python-svm-build": gpgate + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier2 + provide(GPY_NATIVE_STANDALONE), - }), - "python-svm-unittest": gpgate + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk-latest" : tier2 + require(GPY_NATIVE_STANDALONE), "linux:aarch64:jdk-latest" : tier3 + provide(GPY_NATIVE_STANDALONE), - "darwin:amd64:jdk-latest" : daily + t("01:30:00") + provide(GPY_NATIVE_STANDALONE), "darwin:aarch64:jdk-latest" : tier3 + provide(GPY_NATIVE_STANDALONE), "windows:amd64:jdk-latest" : tier3 + provide(GPY_NATIVE_STANDALONE), }), - "python-svm-unittest-bytecode-dsl": gpgate + platform_spec(no_jobs) + bytecode_dsl_gate("python-svm-unittest") + platform_spec({ - "linux:amd64:jdk-latest" : tier2 + provide(GPY_NATIVE_BYTECODE_DSL_STANDALONE), + "python-pgo-profile": gpgate_ee + platform_spec(no_jobs) + platform_spec({ + "linux:amd64:jdk-latest" : post_merge + t("01:30:00") + task_spec({ + run: [["mx", "python-native-pgo"]], + logs+: [ + "default.iprof.gz", + "default.lcov", + "host-inlining.txt.gz", + ], + }), + }), + "python-svm-unittest": gpgate + platform_spec(no_jobs) + platform_spec({ + "linux:amd64:jdk-latest" : tier2 + require(GPY_NATIVE_STANDALONE), + "linux:aarch64:jdk-latest" : tier3 + require(GPY_NATIVE_STANDALONE), + "darwin:aarch64:jdk-latest" : tier3 + require(GPY_NATIVE_STANDALONE), + "windows:amd64:jdk-latest" : tier3 + require(GPY_NATIVE_STANDALONE) + batches(2), + }), + "python-svm-unittest-manual-interpreter": gpgate + platform_spec(no_jobs) + manual_interpreter_gate("python-svm-unittest") + platform_spec({ + "linux:amd64:jdk-latest" : tier2, }), "python-tagged-unittest": gpgate + require(GPY_NATIVE_STANDALONE) + batches(TAGGED_UNITTESTS_SPLIT) + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier2, "linux:aarch64:jdk-latest" : tier3, - "darwin:amd64:jdk-latest" : daily + t("02:00:00"), "darwin:aarch64:jdk-latest" : tier3, "windows:amd64:jdk-latest" : daily + t("02:00:00"), }), - "python-tagged-unittest-bytecode-dsl": gpgate + require(GPY_NATIVE_BYTECODE_DSL_STANDALONE) + batches(TAGGED_UNITTESTS_SPLIT) + bytecode_dsl_gate("python-tagged-unittest") + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk-latest" : tier3, - }), "python-graalvm": gpgate + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), "linux:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), - "darwin:amd64:jdk-latest" : daily + t("01:00:00") + daily, "darwin:aarch64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), "windows:amd64:jdk-latest" : tier3 + require(GRAAL_JDK_LATEST), }), "python-unittest-cpython": cpygate + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier1, }), - "python-unittest-retagger": ut_retagger + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk-latest" : weekly + t("20:00:00"), - "linux:aarch64:jdk-latest" : weekly + t("20:00:00"), - "darwin:aarch64:jdk-latest" : weekly + t("20:00:00"), - "windows:amd64:jdk-latest" : weekly + t("20:00:00"), + "python-unittest-retagger": ut_retagger + platform_spec(no_jobs) + batches(RETAGGER_SPLIT) + platform_spec({ + "linux:amd64:jdk-latest" : weekly + t("20:00:00") + require(GPY_NATIVE_STANDALONE), + "linux:aarch64:jdk-latest" : weekly + t("20:00:00") + require(GPY_NATIVE_STANDALONE), + "darwin:aarch64:jdk-latest" : weekly + t("20:00:00") + require(GPY_NATIVE_STANDALONE), + "windows:amd64:jdk-latest" : weekly + t("20:00:00") + require(GPY_NATIVE_STANDALONE), }), "python-coverage-jacoco-tagged": cov_jacoco_tagged + batches(COVERAGE_SPLIT) + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : weekly + t("20:00:00"), - "darwin:aarch64:jdk21" : weekly + t("20:00:00"), - "windows:amd64:jdk21" : weekly + t("20:00:00"), + "linux:amd64:jdk-latest" : weekly + t("20:00:00"), + "darwin:aarch64:jdk-latest" : weekly + t("20:00:00"), + "windows:amd64:jdk-latest" : weekly + t("20:00:00"), }), "python-coverage-jacoco-base": cov_jacoco_base + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : weekly + t("20:00:00"), - "darwin:aarch64:jdk21" : weekly + t("20:00:00"), - "windows:amd64:jdk21" : weekly + t("20:00:00"), + "linux:amd64:jdk-latest" : weekly + t("20:00:00"), + "darwin:aarch64:jdk-latest" : weekly + t("20:00:00"), + "windows:amd64:jdk-latest" : weekly + t("20:00:00"), }), "python-coverage-truffle": cov_truffle + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk21" : weekly + t("20:00:00"), + "linux:amd64:jdk-latest" : weekly + t("20:00:00"), }), "corp-compliance-watchdog": watchdog + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier1, @@ -295,9 +309,20 @@ "style-ecj": style_gate + task_spec({ tags:: "style,ecjbuild" }) + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier1, }), - // tests with sandboxed backends for various modules (posix, sha3, ctypes, ...) + // tests with sandboxed backends for various modules (posix, sha3, compression, pyexpat, ...) "python-unittest-sandboxed": gpgate_ee + platform_spec(no_jobs) + platform_spec({ - "linux:amd64:jdk-latest" : tier3, + "linux:amd64:jdk21" : daily + t("01:00:00") + provide(GPY_JVM21_STANDALONE), + "linux:aarch64:jdk21" : daily + t("02:00:00") + provide(GPY_JVM21_STANDALONE), + "darwin:aarch64:jdk21" : daily + t("01:00:00") + provide(GPY_JVM21_STANDALONE), + "windows:amd64:jdk21" : daily + t("01:30:00") + provide(GPY_JVM21_STANDALONE), + "linux:amd64:jdk-latest" : tier2 + batches(2) + require(GPY_JVM_STANDALONE), + "linux:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE), + "darwin:aarch64:jdk-latest" : tier3 + require(GPY_JVM_STANDALONE), + }), + "python-unittest-multi-context-sandboxed": gpgate_ee + platform_spec(no_jobs) + platform_spec({ + "linux:amd64:jdk21" : daily + t("01:00:00") + require(GPY_JVM21_STANDALONE), + "linux:aarch64:jdk21" : daily + t("01:30:00") + require(GPY_JVM21_STANDALONE), + "windows:amd64:jdk21" : daily + t("02:00:00") + require(GPY_JVM21_STANDALONE), }), "python-svm-unittest-sandboxed": gpgate_ee + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier3 + provide(GPYEE_NATIVE_STANDALONE), @@ -305,27 +330,9 @@ "tox-example": gpgate_ee + require(GPYEE_NATIVE_STANDALONE) + platform_spec(no_jobs) + platform_spec({ "linux:amd64:jdk-latest" : tier3, }), - "build-wheels": base_gate + platform_spec(no_jobs) + platform_spec({ - "windows:amd64:jdk-latest" : on_demand + t("01:00:00"), - "darwin:aarch64:jdk-latest" : on_demand + t("01:00:00"), - }) + task_spec({ - setup: [ - ["python", "-m", "venv", ".venv"], - ["set-export", "PACKAGES_TO_BUILD", std.join(",", GPY_RELEASE[self.os].wheels)], - ], - run: [ - [ - if self.os == "windows" then ".venv/Scripts/python.exe" else ".venv/bin/python", - "scripts/wheelbuilder/build_wheels.py", - GPY_RELEASE[self.os].url, - ] - ], - "logs"+: [ - "wheelhouse/*.whl", - ], - }), }, + local need_pgo = task_spec({runAfter: ["python-pgo-profile-post_merge-linux-amd64-jdk-latest"]}), local forks_warmup = forks("./mx.graalpython/warmup-fork-counts.json"), local forks_meso = forks("meso.json"), local raw_results = task_spec({ @@ -341,9 +348,7 @@ // not specified as the first arg to `bench_task`. local bench_task_dict = { [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : post_merge + t("08:00:00")}, - "vm_name:graalpython_core" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : post_merge + t("08:00:00") + need_pgo}, "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : daily + t("08:00:00"), "job_type:checkup" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")} }, @@ -351,24 +356,28 @@ "vm_name:cpython" : {"linux:amd64:jdk-latest" : monthly + t("04:00:00")}, "vm_name:pypy" : {"linux:amd64:jdk-latest" : on_demand + t("04:00:00")}, }), - for bench in ["micro", "meso", "macro"] + for bench in ["micro", "meso"] } + { - [bench + "-bytecode-dsl"]: bench_task(bench) + bytecode_dsl_bench + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ee_default_bc_dsl" : {"linux:amd64:jdk-latest" : daily + t("08:00:00")}, - "vm_name:graalpython_enterprise_bc_dsl" : {"linux:amd64:jdk-latest" : daily + t("08:00:00")}, + "macro": bench_task("macro") + internet_access_env + platform_spec(no_jobs) + bench_variants({ + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : post_merge + t("08:00:00") + need_pgo}, + "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : daily + t("08:00:00"), + "job_type:checkup" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")} + }, + "vm_name:graalpython_enterprise_multi" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, + "vm_name:cpython" : {"linux:amd64:jdk-latest" : monthly + t("04:00:00")}, + "vm_name:pypy" : {"linux:amd64:jdk-latest" : on_demand + t("04:00:00")}, }), - for bench in ["micro", "meso", "macro"] + } + { + "macro_oracledb": bench_task("macro_oracledb") + platform_spec(no_jobs) + bench_variants({ + "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, + }) + oracledb_bench_env, } + { [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : post_merge + t("08:00:00")}, - "vm_name:graalpython_core" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalpython_core_panama" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : post_merge + t("08:00:00") + need_pgo}, "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : daily + t("08:00:00"), "job_type:checkup" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")} }, "vm_name:graalpython_enterprise_multi" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, - "vm_name:graalpython_enterprise_panama" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, "vm_name:cpython" : {"linux:amd64:jdk-latest" : monthly + t("04:00:00")}, "vm_name:pypy" : {"linux:amd64:jdk-latest" : on_demand + t("04:00:00")}, }), @@ -377,99 +386,58 @@ // "small" benchmarks have their argument set such that they run in a resonable // time in the interpreter and they are used for interpreter benchmarking [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ce_default_interpreter" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, - "vm_name:graalvm_ee_default_interpreter" : {"linux:amd64:jdk-latest" : daily + t("02:00:00")}, - "vm_name:graalpython_core_interpreter" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, - "vm_name:graalpython_core_native_interpreter" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, + "vm_name:graalvm_ee_default_interpreter" : {"linux:amd64:jdk-latest" : daily + t("02:00:00") + need_pgo}, + "vm_name:graalvm_ee_default_interpreter_uncached" : {"linux:amd64:jdk-latest" : daily + t("02:00:00") + need_pgo}, "vm_name:graalpython_enterprise_interpreter" : {"linux:amd64:jdk-latest" : weekly + t("02:00:00")}, - "vm_name:graalpython_core_interpreter_multi" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, - "vm_name:graalpython_core_native_interpreter_multi" : {"linux:amd64:jdk-latest" : on_demand + t("02:00:00")}, - }), - for bench in ["micro_small", "meso_small"] - } + { - [bench + "-bytecode-dsl"]: bench_task(bench) + bytecode_dsl_bench + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ee_default_interpreter_bc_dsl" : {"linux:amd64:jdk-latest" : daily + t("04:00:00")}, - "vm_name:graalpython_enterprise_interpreter_bc_dsl" : {"linux:amd64:jdk-latest" : daily + t("04:00:00")}, + "vm_name:cpython" : {"linux:amd64:jdk-latest" : weekly + t("02:00:00")}, }), for bench in ["micro_small", "meso_small"] } + { // benchmarks executed via Java embedding driver [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:java_embedding_core_interpreter_multi_shared" : {"linux:amd64:jdk-latest" : weekly + t("02:00:00")}, + "vm_name:java_embedding_enterprise_interpreter_multi_shared" : {"linux:amd64:jdk-latest" : weekly + t("02:00:00")}, }), for bench in ["java_embedding_meso"] } + { [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalpython_core" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : daily + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : daily + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_core_multi_tier" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_enterprise_multi_tier" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ce_default_multi_tier" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ee_default_multi_tier" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_core_3threads" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_enterprise_3threads" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ce_default_3threads" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ee_default_3threads" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_core_multi_tier_3threads" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_enterprise_multi_tier_3threads" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ce_default_multi_tier_3threads" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalvm_ee_default_multi_tier_3threads" : {"linux:amd64:jdk-latest" : weekly + t("05:00:00") + forks_warmup}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : daily + t("05:00:00") + forks_warmup + need_pgo}, "vm_name:pypy" : {"linux:amd64:jdk-latest" : on_demand + t("01:00:00")}, }), for bench in ["warmup"] - } + { - [bench + "-bytecode-dsl"]: bench_task(bench) + bytecode_dsl_bench + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ee_default_bc_dsl" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - "vm_name:graalpython_enterprise_bc_dsl" : {"linux:amd64:jdk-latest" : on_demand + t("05:00:00") + forks_warmup}, - }), - for bench in ["warmup"] } + { [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalpython_enterprise_interpreter" : {"linux:amd64:jdk-latest" : post_merge + t("00:30:00")}, + "vm_name:graalvm_ee_default_interpreter" : {"linux:amd64:jdk-latest" : post_merge + t("02:00:00") + need_pgo}, + "vm_name:graalpython_enterprise_interpreter" : {"linux:amd64:jdk-latest" : weekly + t("02:00:00")}, + "vm_name:cpython" : {"linux:amd64:jdk-latest" : weekly + t("01:00:00")}, }), - for bench in ["heap"] + for bench in ["heap", "micro_small_heap"] } + { // interop benchmarks only for graalpython, weekly is enough [bench]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:java_jmh_core" : {"linux:amd64:jdk-latest" : daily + t("04:00:00")}, "vm_name:java_jmh_enterprise" : {"linux:amd64:jdk-latest" : daily + t("04:00:00")}, }), for bench in ["jmh"] } + { // benchmarks with many forks for weekly performance reports [bench + "-forks"]: bench_task(bench) + platform_spec(no_jobs) + bench_variants({ - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("10:00:00") + forks_meso}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("10:00:00") + forks_meso}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("10:00:00") + forks_meso + need_pgo}, }), for bench in ["meso"] } + { // benchmarks with community benchmark suites for external numbers [bench]: bench_task(bench, PY_BENCHMARKS) + platform_spec(no_jobs) + raw_results + bench_variants({ - "vm_name:graalpython_core" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00") + need_pgo}, "vm_name:cpython_launcher" : {"linux:amd64:jdk-latest" : monthly + t("08:00:00")}, "vm_name:pypy_launcher" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, }), for bench in ["pyperformance"] - } + { - // Bytecode DSL benchmarks with community benchmark suites for external numbers - [bench + "-bytecode-dsl"]: bench_task(bench, PY_BENCHMARKS) + platform_spec(no_jobs) + raw_results + bench_variants({ - "vm_name:graalvm_ee_default_bc_dsl" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, - }), - for bench in ["pyperformance"] } + { // benchmarks with community benchmark suites for external numbers [bench]: bench_task(bench, PY_BENCHMARKS) + platform_spec(no_jobs) + raw_results + bench_variants({ - "vm_name:graalpython_core" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalpython_core_panama" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, "vm_name:graalpython_enterprise" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, - "vm_name:graalpython_enterprise_panama" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalvm_ce_default" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, - "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00")}, + "vm_name:graalvm_ee_default" : {"linux:amd64:jdk-latest" : weekly + t("08:00:00") + need_pgo}, "vm_name:cpython_launcher" : {"linux:amd64:jdk-latest" : monthly + t("08:00:00")}, "vm_name:pypy_launcher" : {"linux:amd64:jdk-latest" : on_demand + t("08:00:00")}, }), @@ -490,10 +458,10 @@ {'defined_in': std.thisFile} + b for b in self.processed_gate_builds.list + self.processed_bench_builds.list ]) ) - ) + [ + ) + self.codeowners_builds + [ { name: "graalpy-website-build", - targets: ["gate"], + targets: ["tier1"], guard: { includes: ["docs/user/**", "docs/site/**"], }, @@ -506,7 +474,7 @@ packages: { ruby: "==3.2.2", libyaml: "==0.2.5", - mx: "7.34.1", + mx: "==7.82.0", python3: "==3.8.10", }, environment: { @@ -520,11 +488,10 @@ ["export", "PATH=$GEM_HOME/bin:$PATH"], ["gem", "install", "--no-document", "--source", $.overlay_imports.RUBYGEMS_MIRROR, "bundler", "-v", "2.5.9"], ["git", "clone", "-b", "main", $.overlay_imports.JEKYLL_THEME_GIT], - ["cd", "graal-languages-jekyll-theme"], - ["gem", "build", "graal-languages-jekyll-theme.gemspec"], - ["mkdir", "-p", "../docs/site/vendor/cache"], - ["cp", "graal-languages-jekyll-theme-*.gem", "../docs/site/vendor/cache"], - ["cd", "../docs/site"], + ["cd", "docs/site"], + ["bundle", "config", "set", "mirror.https://rubygems.org", $.overlay_imports.RUBYGEMS_MIRROR], + ["bundle", "config", "set", "--local", "local.graal-languages-jekyll-theme", "../../graal-languages-jekyll-theme"], + ["bundle", "update", "graal-languages-jekyll-theme"], ["bundle", "install"], ["bundle", "exec", "jekyll", "build"], ], @@ -555,7 +522,7 @@ targets: ["deploy"], capabilities: ["linux", "amd64"], packages: { - mx: "7.34.1", + mx: "==7.82.0", python3: "==3.8.10", }, requireArtifacts: [ diff --git a/ci/AGENTS.md b/ci/AGENTS.md new file mode 100644 index 0000000000..ce604096dc --- /dev/null +++ b/ci/AGENTS.md @@ -0,0 +1,19 @@ +# ci/ — CI DEFINITIONS + +## OVERVIEW +Jsonnet/libsonnet CI definitions consumed by GitHub Actions matrix generation. + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Main pipelines | `../ci.jsonnet`, `python-gate.libsonnet` | Defines gates/tags executed in CI. | +| Shared constants | `constants.libsonnet` | Shared settings used across CI definitions. | +| Helpers | `utils.libsonnet` | Common functions/macros. | + +## CONVENTIONS +- GitHub workflows typically call `ci-matrix-gen.yml`, which evaluates `ci.jsonnet` and these libraries. + +## ANTI-PATTERNS +- Don’t encode secrets or environment-specific paths here. +- Keep changes compatible with matrix generation (small diffs, deterministic output). +- NEVER edit CI files in `./graal` diff --git a/ci/constants.libsonnet b/ci/constants.libsonnet index 1d6034e903..53809d09e7 100644 --- a/ci/constants.libsonnet +++ b/ci/constants.libsonnet @@ -1,5 +1,5 @@ { - local graal_common = import "graal/ci/common.jsonnet", + local common = import "graal/ci/common.jsonnet", MX_VERSION:: "HEAD", @@ -24,27 +24,23 @@ }, TARGET:: { - onDemand: graal_common.frequencies.on_demand.targets, - postMerge: graal_common.frequencies.post_merge.targets, - daily: graal_common.frequencies.daily.targets, - weekly: graal_common.frequencies.weekly.targets, - monthly: graal_common.frequencies.monthly.targets, - gate: graal_common.frequencies.gate.targets, + onDemand: common.frequencies.on_demand.targets, + postMerge: common.frequencies.post_merge.targets, + daily: common.frequencies.daily.targets, + weekly: common.frequencies.weekly.targets, + monthly: common.frequencies.monthly.targets, + gate: common.frequencies.gate.targets, }, NOTIFY_GROUPS:: ["tim.felgentreff@oracle.com"], local ENV = { - graalpy_svm_ce: ["--env", "native-ce"], graalpy_svm_ee: ["--env", "native-ee"], - graalpy_jvm_ce: ["--env", "jvm-ce-libgraal"], graalpy_jvm_ee: ["--env", "jvm-ee-libgraal"], - libgraal_ce: ["--env", "../../graal/vm/mx.vm/libgraal"], libgraal_ee: ["--env", "../../graal-enterprise/vm-enterprise/mx.vm-enterprise/libgraal-enterprise"], }, local DY = { - ce: "/vm", ee: "/vm-enterprise,/graalpython-enterprise", }, @@ -57,20 +53,19 @@ local PYVM_CONFIG = { default: "default", - default_bc_dsl: "default-bc-dsl", + default_manual: "default-manual", default_multi: "default-multi", interpreter: "interpreter", - interpreter_bc_dsl: "interpreter-bc-dsl", + interpreter_manual: "interpreter-manual", + interpreter_uncached: "interpreter-uncached", native_interpreter: "native-interpreter", - native_interpreter_bc_dsl: "native-interpreter-bc-dsl", + native_interpreter_manual: "native-interpreter-manual", interpreter_multi: "interpreter-multi", native_interpreter_multi: "native-interpreter-multi", - default_multi_tier: "default-multi-tier", native: "native", - native_bc_dsl: "native-bc-dsl", + native_manual: "native-manual", native_multi: "native-multi", launcher: "launcher", - panama: "panama", }, local JAVA_EMBEDDING_VM_CONFIG = { @@ -80,33 +75,16 @@ // the host VMs local JVM_VM = { - graaljdk_ce: { - dy: ["--dynamicimports", DY.ce], - env: ENV.graalpy_jvm_ce, - edition: 'ce', - }, graaljdk_ee: { dy: ["--dynamicimports", DY.ee], env: ENV.graalpy_jvm_ee, edition: 'ee', }, - graal_native_image_ce: { - dy: ["--dynamicimports", DY.ce], - env: ENV.graalpy_svm_ce, - edition: 'ce', - }, graal_native_image_ee: { dy: ["--dynamicimports", DY.ee], env: ENV.graalpy_svm_ee, edition: 'ee', }, - server_libgraal_ce: { - jvm: 'server', - jvm_config: 'graal-core-libgraal', - dy: ["--dynamicimports", DY.ce], - env: ENV.libgraal_ce, - edition: 'ce', - }, server_libgraal_ee: { jvm: 'server', jvm_config: 'graal-enterprise-libgraal', @@ -128,25 +106,29 @@ python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.default, }, - graalpython_bc_dsl: { + graalpython_manual: { python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.default_bc_dsl, + python_vm_config: PYVM_CONFIG.default_manual, }, graalpython_interpreter: { python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.interpreter, }, - graalpython_interpreter_bc_dsl: { + graalpython_interpreter_manual: { python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.interpreter_bc_dsl, + python_vm_config: PYVM_CONFIG.interpreter_manual, + }, + graalpython_interpreter_uncached: { + python_vm: PYVM.graalpython, + python_vm_config: PYVM_CONFIG.interpreter_uncached, }, graalpython_native_interpreter: { python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.native_interpreter, }, - graalpython_native_interpreter_bc_dsl: { + graalpython_native_interpreter_manual: { python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.native_interpreter_bc_dsl, + python_vm_config: PYVM_CONFIG.native_interpreter_manual, }, graalpython_multi: { python_vm: PYVM.graalpython, @@ -160,26 +142,18 @@ python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.native_interpreter_multi, }, - graalpython_multi_tier: { - python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.default_multi_tier, - }, graalpython_native: { python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.native, }, - graalpython_native_bc_dsl: { + graalpython_native_manual: { python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.native_bc_dsl, + python_vm_config: PYVM_CONFIG.native_manual, }, graalpython_native_multi: { python_vm: PYVM.graalpython, python_vm_config: PYVM_CONFIG.native_multi, }, - graalpython_panama: { - python_vm: PYVM.graalpython, - python_vm_config: PYVM_CONFIG.panama, - }, java_embedding_multi_shared: { python_vm: PYVM.graalpython, python_vm_config: JAVA_EMBEDDING_VM_CONFIG.java_embedding_multi_shared, @@ -208,55 +182,25 @@ local VM = { // graalpy jvm standalones - graalpython_core: PYTHON_VM.graalpython + JVM_VM.graaljdk_ce, - graalpython_core_bc_dsl: PYTHON_VM.graalpython_bc_dsl + JVM_VM.graaljdk_ce, - graalpython_core_interpreter: PYTHON_VM.graalpython_interpreter + JVM_VM.graaljdk_ce, - graalpython_core_interpreter_bc_dsl: PYTHON_VM.graalpython_interpreter_bc_dsl + JVM_VM.graaljdk_ce, - graalpython_core_multi: PYTHON_VM.graalpython_multi + JVM_VM.graaljdk_ce, - graalpython_core_interpreter_multi: PYTHON_VM.graalpython_interpreter_multi + JVM_VM.graaljdk_ce, - graalpython_core_multi_tier: PYTHON_VM.graalpython_multi_tier + JVM_VM.graaljdk_ce, graalpython_enterprise: PYTHON_VM.graalpython + JVM_VM.graaljdk_ee, - graalpython_enterprise_bc_dsl: PYTHON_VM.graalpython_bc_dsl + JVM_VM.graaljdk_ee, + graalpython_enterprise_manual: PYTHON_VM.graalpython_manual + JVM_VM.graaljdk_ee, graalpython_enterprise_multi: PYTHON_VM.graalpython_multi + JVM_VM.graaljdk_ee, - graalpython_enterprise_multi_tier: PYTHON_VM.graalpython_multi_tier + JVM_VM.graaljdk_ee, graalpython_enterprise_interpreter: PYTHON_VM.graalpython_interpreter + JVM_VM.graaljdk_ee, - graalpython_enterprise_interpreter_bc_dsl: PYTHON_VM.graalpython_interpreter_bc_dsl + JVM_VM.graaljdk_ee, - graalpython_core_native: PYTHON_VM.graalpython_native + JVM_VM.graaljdk_ce, - graalpython_core_native_bc_dsl: PYTHON_VM.graalpython_native_bc_dsl + JVM_VM.graaljdk_ce, - graalpython_core_native_interpreter: PYTHON_VM.graalpython_native_interpreter + JVM_VM.graaljdk_ce, - graalpython_core_native_interpreter_bc_dsl: PYTHON_VM.graalpython_native_interpreter_bc_dsl + JVM_VM.graaljdk_ce, - graalpython_core_native_multi: PYTHON_VM.graalpython_native_multi + JVM_VM.graaljdk_ce, - graalpython_core_native_interpreter_multi: PYTHON_VM.graalpython_native_interpreter_multi + JVM_VM.graaljdk_ce, + graalpython_enterprise_interpreter_manual: PYTHON_VM.graalpython_interpreter_manual + JVM_VM.graaljdk_ee, graalpython_enterprise_native: PYTHON_VM.graalpython_native + JVM_VM.graaljdk_ee, - graalpython_enterprise_native_bc_dsl: PYTHON_VM.graalpython_native_bc_dsl + JVM_VM.graaljdk_ee, + graalpython_enterprise_native_manual: PYTHON_VM.graalpython_native_manual + JVM_VM.graaljdk_ee, graalpython_enterprise_native_multi: PYTHON_VM.graalpython_native_multi + JVM_VM.graaljdk_ee, - graalpython_core_panama: PYTHON_VM.graalpython_panama + JVM_VM.graaljdk_ce, - graalpython_enterprise_panama: PYTHON_VM.graalpython_panama + JVM_VM.graaljdk_ee, // graalpy native standalones - graalvm_ce_default: PYTHON_VM.graalpython + JVM_VM.graal_native_image_ce, - graalvm_ce_default_interpreter: PYTHON_VM.graalpython_interpreter + JVM_VM.graal_native_image_ce, graalvm_ee_default: PYTHON_VM.graalpython + JVM_VM.graal_native_image_ee, - graalvm_ee_default_bc_dsl: PYTHON_VM.graalpython_bc_dsl + JVM_VM.graal_native_image_ee, + graalvm_ee_default_manual: PYTHON_VM.graalpython_manual + JVM_VM.graal_native_image_ee, graalvm_ee_default_interpreter: PYTHON_VM.graalpython_interpreter + JVM_VM.graal_native_image_ee, - graalvm_ee_default_interpreter_bc_dsl: PYTHON_VM.graalpython_interpreter_bc_dsl + JVM_VM.graal_native_image_ee, - graalvm_ce_default_multi_tier: PYTHON_VM.graalpython_multi_tier + JVM_VM.graal_native_image_ce, - graalvm_ee_default_multi_tier: PYTHON_VM.graalpython_multi_tier + JVM_VM.graal_native_image_ee, - - // only 3 compiler threads - graalpython_core_3threads: PYTHON_VM.graalpython + JVM_VM.graaljdk_ce + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalpython_enterprise_3threads: PYTHON_VM.graalpython + JVM_VM.graaljdk_ee + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalvm_ce_default_3threads: PYTHON_VM.graalpython + JVM_VM.graal_native_image_ce + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalvm_ee_default_3threads: PYTHON_VM.graalpython + JVM_VM.graal_native_image_ee + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalpython_core_multi_tier_3threads: PYTHON_VM.graalpython_multi_tier + JVM_VM.graaljdk_ce + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalpython_enterprise_multi_tier_3threads: PYTHON_VM.graalpython_multi_tier + JVM_VM.graaljdk_ee + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalvm_ce_default_multi_tier_3threads: PYTHON_VM.graalpython_multi_tier + JVM_VM.graal_native_image_ce + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, - graalvm_ee_default_multi_tier_3threads: PYTHON_VM.graalpython_multi_tier + JVM_VM.graal_native_image_ee + {python_vm_config: super.python_vm_config + "-3-compiler-threads"}, + graalvm_ee_default_interpreter_uncached: PYTHON_VM.graalpython_interpreter_uncached + JVM_VM.graal_native_image_ee, + graalvm_ee_default_interpreter_manual: PYTHON_VM.graalpython_interpreter_manual + JVM_VM.graal_native_image_ee, // Java embedding - java_embedding_core_multi_shared: PYTHON_VM.java_embedding_multi_shared + JVM_VM.server_libgraal_ce, - java_embedding_core_interpreter_multi_shared: PYTHON_VM.java_embedding_interpreter_multi_shared + JVM_VM.server_libgraal_ce, - java_jmh_core: JVM_VM.server_libgraal_ce, + java_embedding_enterprise_multi_shared: PYTHON_VM.java_embedding_multi_shared + JVM_VM.server_libgraal_ee, + java_embedding_enterprise_interpreter_multi_shared: PYTHON_VM.java_embedding_interpreter_multi_shared + JVM_VM.server_libgraal_ee, java_jmh_enterprise: JVM_VM.server_libgraal_ee, // basline vms diff --git a/ci/graal/ci/ci_common/bench-common.libsonnet b/ci/graal/ci/ci_common/bench-common.libsonnet index d5af90b929..27014ae5d7 100644 --- a/ci/graal/ci/ci_common/bench-common.libsonnet +++ b/ci/graal/ci/ci_common/bench-common.libsonnet @@ -34,7 +34,7 @@ # max number of threads to use for benchmarking in general # the goal being to limit parallelism on very large servers which may not be respresentative of real-world scenarios bench_max_threads:: { - restrict_threads:: 36 + restrict_threads:: if self.arch == 'amd64' then 36 else 32, }, bench_no_thread_cap:: { @@ -99,7 +99,27 @@ default_numa_node:: 0, num_threads:: 160, hyperthreading:: false - } + }, + hr350a:: common.linux_aarch64 + self._bench_machine + { + machine_name:: "hr350a", + capabilities+: ["tmpfs25g"], + numa_nodes:: [0], + default_numa_node:: 0, + num_threads:: 32, + hyperthreading:: false + }, + osprey:: common.linux_aarch64 + self._bench_machine + { + machine_name:: "osprey", + capabilities+: ["tmpfs25g"], + numa_nodes:: [0], + default_numa_node:: 0, + num_threads:: 32, + hyperthreading:: false + }, + local contains(a_str, substr) = std.length(std.findSubstr(substr, a_str)) > 0, + # Useful to distribute the benchmark load between two machine types, but always stay consistent for the same benchmark suite + # This guarantees comparability of results, whatever the platform/context, for each suite + hr350a_or_osprey(suite=null):: if suite != null && std.count([contains(s, suite) for s in ["barista", "renaissance"]], true) > 0 then self.osprey else self.hr350a, }, hwloc_cmd(cmd, num_threads, node, hyperthreading, max_threads_per_node):: diff --git a/ci/graal/ci/ci_common/ci-check.libsonnet b/ci/graal/ci/ci_common/ci-check.libsonnet index 2224e6bd7b..777b98eb16 100644 --- a/ci/graal/ci/ci_common/ci-check.libsonnet +++ b/ci/graal/ci/ci_common/ci-check.libsonnet @@ -1,12 +1,18 @@ +local ci = import '../../ci.jsonnet'; local std_get = (import 'common-utils.libsonnet').std_get; { + local effective_targets(build) = std.map(function(target) if std.startsWith(target, "tier") then ci.tierConfig[target] else target, build.targets), + local periodic_targets = ["daily", "weekly", "monthly", "post-merge", "opt-post-merge"], + local has_periodic_target(build) = std.length(std.setInter(std.set(effective_targets(build)), std.set(periodic_targets))) != 0, + # check that all non [gate, ondemand] entries have notify_emails or notify_groups defined local missing_notify(builds) = { - [x.name]: std_get(x, "defined_in") for x in builds if !std.objectHas(x, "notify_emails") && !std.objectHasAll(x, "notify_groups") && std.length(std.setInter(std.set(x.targets), std.set(["daily", "weekly", "monthly", "post-merge", "opt-post-merge"]))) != 0 + [x.name]: {defined_in: std_get(x, "defined_in"), targets: std_get(x, "targets")} + for x in builds if !std.objectHas(x, "notify_emails") && !std.objectHasAll(x, "notify_groups") && has_periodic_target(x) }, - # check that all non entries have defined_in set + # check that all entries have defined_in set local missing_defined_in(builds) = { [x.name]: std_get(x, "defined_in") for x in builds if !std.objectHas(x, "defined_in") }, diff --git a/ci/graal/ci/ci_common/common.jsonnet b/ci/graal/ci/ci_common/common.jsonnet index 1cfc8ef29b..1405227b1f 100644 --- a/ci/graal/ci/ci_common/common.jsonnet +++ b/ci/graal/ci/ci_common/common.jsonnet @@ -128,20 +128,18 @@ common + common.frequencies + { "*.bgv", "*/graal_dumps/*/*", ], - timelimit: "30:00", }, local linux_deps_extras = { packages+: { - "apache/ant": ">=1.9.4", + "apache/ant": "==1.10.1", }, }, linux_amd64: common.linux_amd64 + graal_common_extras + linux_deps_extras, linux_amd64_ol9: common.linux_amd64_ol9 + graal_common_extras + linux_deps_extras, linux_amd64_ubuntu: common.linux_amd64_ubuntu + graal_common_extras, - linux_aarch64: linux_deps_extras + common.linux_aarch64 + graal_common_extras, - linux_aarch64_ol9: linux_deps_extras + common.linux_aarch64_ol9 + graal_common_extras, - darwin_amd64: common.darwin_amd64 + graal_common_extras, + linux_aarch64: common.linux_aarch64 + graal_common_extras + linux_deps_extras, + linux_aarch64_ol9: common.linux_aarch64_ol9 + graal_common_extras + linux_deps_extras, darwin_aarch64: common.darwin_aarch64 + graal_common_extras, windows_amd64: common.windows_amd64 + graal_common_extras, windows_server_2016_amd64: common.windows_server_2016_amd64 + graal_common_extras, diff --git a/ci/graal/ci/ci_common/run-spec-impl.libsonnet b/ci/graal/ci/ci_common/run-spec-impl.libsonnet index 7f514f87a6..a5512ca49c 100644 --- a/ci/graal/ci/ci_common/run-spec-impl.libsonnet +++ b/ci/graal/ci/ci_common/run-spec-impl.libsonnet @@ -95,7 +95,7 @@ local std_get = (import "../../ci/ci_common/common-utils.libsonnet").std_get; else // exclusion assert std.length(excluded) == std.length(_values) : "Cannot mix inclusion with exclusion (either all entries start with '!' or none): " + _values; - std.setDiff(std.objectFieldsAll(feature_map[self.feature]), excluded) + std.setDiff(std.set(std.objectFieldsAll(feature_map[self.feature])), std.set(excluded)) } ; local is_feature_desc(key) = std.member(feature_order, get_feature_value_pair(key).feature); diff --git a/ci/graal/ci/ci_common/run-spec-tools.libsonnet b/ci/graal/ci/ci_common/run-spec-tools.libsonnet index cada794322..db7da13300 100644 --- a/ci/graal/ci/ci_common/run-spec-tools.libsonnet +++ b/ci/graal/ci/ci_common/run-spec-tools.libsonnet @@ -54,30 +54,9 @@ local std_get = (import "../../ci/ci_common/common-utils.libsonnet").std_get; local table = [ ["name", "variant", task_details_title] + platform_titles] + cols; table , - // Removes the 'timelimit' property from an object. - // Usually, this is used to remove hard-coded (default) timelimits defined in `ci/ci_common/common.jsonnet`. - // These definitions assume that the os/arch definition comes first and will be refined later. - // With run-spec, however, this is not true in general because the os/arch is only fixed later - // in the pipeline. Thus, hard-coded timelimits would override any previous settings. To resolve - // this, we delete the default value altogether and explicitly set the timelimits for all jobs. - // - // Implementation note: we cannot set the value to `null` and use `std.prune` because that deletes hidden fields. - delete_timelimit(b):: - local public_fields = std.objectFields(b); - std.foldl(function(acc, k) acc + - local value = b[k]; - if std.member(public_fields, k) then - if std.type(value) == "string" then - { [k]: value } - else - { [k]+: value } - else - if std.type(value) == "string" then - { [k]:: value } - else - { [k]+:: value } - , - [k for k in std.objectFieldsAll(b) if k != "timelimit"], - {} - ), + // Check there is no 'timelimit' property on an object, + // so that it is safe to add the timelimit later and ordering won't matter. + check_no_timelimit(b):: + assert !std.objectHasAll(b, "timelimit") : "b"; + b, } \ No newline at end of file diff --git a/ci/graal/ci/common.jsonnet b/ci/graal/ci/common.jsonnet index 4272ca2d15..d12957a22c 100644 --- a/ci/graal/ci/common.jsonnet +++ b/ci/graal/ci/common.jsonnet @@ -59,15 +59,26 @@ local common_json = import "../common.json"; 'oraclejdk24': jdk_base + common_json.jdks["oraclejdk24"] + { jdk_version:: 24 }, } + { [name]: jdk_base + common_json.jdks[name] + { jdk_version:: 25 } - for name in ["oraclejdk25"] + variants("labsjdk-ce-25") + variants("labsjdk-ee-25") + for name in ["oraclejdk25"] + } + { + # Synthesize labsjdk-*-25 from labsjdk-*-latest + # This is intended for jobs that specifically need the 25 LTS JDK (e.g., espresso for its guest). + # When running the compiler or the native image generator "latest" should be used instead. + # When latest moves past 25, jobs using 25 should be reviwed and if they are still needed labsjdk-(ce|ee)-25 should + # be added to common.json. + # Note that the assert below unfortunately doesn't work in the sjsonnet version used currently in the CI (GR-40975). + [std.strReplace(name, 'latest', '25')]: jdk_base + common_json.jdks[name] + { assert parse_labsjdk_version(self) == 25, jdk_version:: 25 } + for name in variants("labsjdk-ce-latest") + variants("labsjdk-ee-latest") } + { [name]: jdk_base + common_json.jdks[name] + { jdk_version:: parse_labsjdk_version(self), jdk_name:: "jdk-latest"} for name in ["oraclejdk-latest"] + variants("labsjdk-ce-latest") + variants("labsjdk-ee-latest") } + { 'graalvm-ee-21': jdk_base + common_json.jdks["graalvm-ee-21"] + { jdk_version:: 21 }, + 'graalvm-ee-25-ea': jdk_base + common_json.jdks["graalvm-ee-25-ea"] + { jdk_version:: 25 }, }, - # We do not want to expose galahad-jdk - assert std.assertEqual([x for x in std.objectFields(common_json.jdks) if x != "galahad-jdk"], std.objectFields(jdks_data)), + # We do not want to expose galahad-jdk, labsjdk-(ce|ee)-25 are synthetized from latest + local is_labsjdk_25(x) = std.startsWith(x, "labsjdk-ee-25") || std.startsWith(x, "labsjdk-ce-25"), + assert std.assertEqual([x for x in std.objectFields(common_json.jdks) if x != "galahad-jdk"], [x for x in std.objectFields(jdks_data) if !is_labsjdk_25(x)]), # Verify oraclejdk-latest and labsjdk-ee-latest versions match assert local _labsjdk = common_json.jdks["labsjdk-ee-latest"]; @@ -109,7 +120,8 @@ local common_json = import "../common.json"; oraclejdkLatest: self["oraclejdk-latest"], }, - # The devkits versions reflect those used to build the JVMCI JDKs (e.g., see devkit_platform_revisions in /make/conf/jib-profiles.js) + # The devkits versions reflect those used to build the JVMCI JDKs (e.g., see devkit_platform_revisions in /make/conf/jib-profiles.js). + # See deps.windows_devkit to add a devkit on windows conveniently. devkits: { "windows-jdk17": { packages+: { "devkit:VS2022-17.1.0+1": "==0" }}, "windows-jdk19": { packages+: { "devkit:VS2022-17.1.0+1": "==0" }}, @@ -154,8 +166,8 @@ local common_json = import "../common.json"; "Graal diagnostic output saved in '(?P[^']+)'", # Keep in sync with jdk.graal.compiler.debug.DebugContext#DUMP_FILE_MESSAGE_REGEXP "Dumping debug output to '(?P[^']+)'", - # Keep in sync with com.oracle.svm.hosted.NativeImageOptions#DEFAULT_ERROR_FILE_NAME - " (?P.+/svm_err_b_\\d+T\\d+\\.\\d+_pid\\d+\\.md)", + # Keep in sync with com.oracle.svm.hosted.ProgressReporter#printErrorMessage + "Please inspect the generated error report at: '(?P[^']+)'", # Keep in sync with jdk.graal.compiler.test.SubprocessUtil#makeArgfile "@(?P.*SubprocessUtil-argfiles.*\\.argfile)", # Keep in sync with com.oracle.truffle.api.test.SubprocessTestUtils#makeArgfile @@ -174,17 +186,10 @@ local common_json = import "../common.json"; # These dependencies are not included by default in any platform object - eclipse: { - downloads+: { - ECLIPSE: { - name: "eclipse", - version: common_json.eclipse.version, - platformspecific: true, - } - }, - environment+: { - ECLIPSE_EXE: "$ECLIPSE/eclipse", - }, + # Not included by default in $.windows_amd64 and $.windows_server_2016_amd64 because it needs jdk_name. + # As a note, Native Image needs this to build. + windows_devkit:: { + packages+: if self.os == "windows" then $.devkits["windows-" + self.jdk_name].packages else {}, }, jdt: { @@ -239,24 +244,35 @@ local common_json = import "../common.json"; } else {}, }, + maven:: { + local this = self, + packages+: (if self.os == "linux" && self.arch == "amd64" then { + maven: '==3.9.10', + } else {}), + # no maven package available on other platforms + downloads+: (if self.os != "linux" || self.arch != "amd64" then { + # GR-68921: 3.9.10 does not work on Windows + MAVEN_HOME: {name: 'maven', version: (if this.os == "windows" then '3.3.9' else '3.9.10'), platformspecific: false}, + } else {}), + setup+: (if self.os != "linux" || self.arch != "amd64" then [ + ['set-export', 'PATH', (if self.os == "windows" then '$MAVEN_HOME\\bin;$PATH' else '$MAVEN_HOME/bin:$PATH')], + ] else []), + }, + + espresso:: { + downloads+: { + EXTRA_JAVA_HOMES+: { + pathlist+: [jdks_data["oraclejdk21"], jdks_data["oraclejdk25"]], + } + } + }, + sulong:: self.cmake + { packages+: if self.os == "windows" then { msvc_source: "==14.0", } else {}, }, - truffleruby:: { - packages+: (if self.os == "linux" && self.arch == "amd64" then { - ruby: "==3.2.2", # Newer version, also used for benchmarking - } else if (self.os == "windows") then - error('truffleruby is not supported on windows') - else { - ruby: "==3.0.2", - }) + (if self.os == "linux" then { - libyaml: "==0.2.5", - } else {}), - }, - graalnodejs:: { local this = self, packages+: if self.os == "linux" then { @@ -275,24 +291,41 @@ local common_json = import "../common.json"; } else {}, }, - graalpy:: self.gradle + self.cmake + { + graalpy:: self.gradle + self.cmake + self.maven + { packages+: if (self.os == "linux") then { libffi: '==3.2.1', bzip2: '==1.0.6', zlib: '==1.2.11', - maven: "==3.6.3", } else {}, }, wasm:: { downloads+: { - WABT_DIR: {name: 'wabt', version: '1.0.36', platformspecific: true}, + WABT_DIR: {name: 'wabt', version: '1.0.41', platformspecific: true}, }, environment+: { WABT_DIR: '$WABT_DIR/bin', }, }, + wasm_ol8:: { + downloads+: { + WABT_DIR: {name: 'wabt', version: '1.0.41-ol8', platformspecific: true}, + }, + environment+: { + WABT_DIR: '$WABT_DIR/bin', + }, + }, + + emsdk_ol8:: { + downloads+: { + EMSDK_DIR: {name: 'emsdk', version: '4.0.10', platformspecific: true}, + }, + environment+: { + EMCC_DIR: '$EMSDK_DIR/upstream/emscripten/' + } + }, + fastr:: { # Note: On both Linux and MacOS, FastR depends on the gnur module and on gfortran # of a specific version (4.8.5 on Linux, 10.2.0 on MacOS) @@ -305,9 +338,7 @@ local common_json = import "../common.json"; pcre2: '==10.37', gnur: '==4.0.3-gcc4.8.5-pcre2', } + if (std.objectHasAll(self, 'os_distro') && self['os_distro'] == 'ol' && std.objectHasAll(self, 'os_distro_version') && self['os_distro_version'] == '9') then {curl: '==7.78.0'} else {curl: '==7.50.1'} - else if (self.os == "darwin" && self.arch == "amd64") then { - 'pcre2': '==10.37', - } else {}, + else {}, environment+: if (self.os == "linux" && self.arch == "amd64") then { TZDIR: '/usr/share/zoneinfo', @@ -318,25 +349,14 @@ local common_json = import "../common.json"; GNUR_HOME_BINARY: '/cm/shared/apps/gnur/4.0.3_gcc4.8.5_pcre2-10.37/R-4.0.3', FASTR_RELEASE: 'true', } - else if (self.os == "darwin" && self.arch == "amd64") then { - FASTR_FC: '/cm/shared/apps/gcc/8.3.0/bin/gfortran', - FASTR_CC: '/cm/shared/apps/gcc/8.3.0/bin/gcc', - TZDIR: '/usr/share/zoneinfo', - PKG_INCLUDE_FLAGS_OVERRIDE : '-I/cm/shared/apps/pcre2/pcre2-10.37/include -I/cm/shared/apps/bzip2/1.0.6/include -I/cm/shared/apps/xz/5.2.2/include -I/cm/shared/apps/curl/7.50.1/include', - PKG_LDFLAGS_OVERRIDE : '-L/cm/shared/apps/bzip2/1.0.6/lib -L/cm/shared/apps/xz/5.2.2/lib -L/cm/shared/apps/pcre2/pcre2-10.37/lib -L/cm/shared/apps/curl/7.50.1/lib -L/cm/shared/apps/gcc/10.2.0/lib -L/usr/lib', - FASTR_RELEASE: 'true', - } else {}, + else {}, downloads+: if (self.os == "linux" && self.arch == "amd64") then { BLAS_LAPACK_DIR: { name: 'fastr-403-blas-lapack-gcc', version: '4.8.5', platformspecific: true }, F2C_BINARY: { name: 'f2c-binary', version: '7', platformspecific: true }, FASTR_RECOMMENDED_BINARY: { name: 'fastr-recommended-pkgs', version: '16', platformspecific: true }, } - else if (self.os == "darwin" && self.arch == "amd64") then { - BLAS_LAPACK_DIR: { name: "fastr-403-blas-lapack-gcc", version: "8.3.0", platformspecific: true }, - F2C_BINARY: { name: 'f2c-binary', version: '7', platformspecific: true }, - FASTR_RECOMMENDED_BINARY: { name: 'fastr-recommended-pkgs', version: '16', platformspecific: true }, - } else {}, + else {}, catch_files+: if (self.os != "windows" && self.arch == "amd64") then [ 'GNUR_CONFIG_LOG = (?P.+\\.log)', 'GNUR_MAKE_LOG = (?P.+\\.log)', @@ -356,7 +376,6 @@ local common_json = import "../common.json"; "*/*.log", "*/svmbuild/*.log", "*/svmbuild/images/*.log", - "*/*/stripped/*.map", "*/callgrind.*", "*.log", ], @@ -468,8 +487,8 @@ local common_json = import "../common.json"; }, local linux = { os:: "linux", capabilities+: [self.os] }, - # Run darwin jobs on Big Sur or later by excluding all older versions - local darwin = { os:: "darwin", capabilities+: [self.os, "!darwin_sierra", "!darwin_mojave", "!darwin_catalina"] }, + # Run darwin jobs on Sonoma or later by excluding all older versions + local darwin = { os:: "darwin", capabilities+: [self.os, "!darwin_bigsur", "!darwin_ventura", "!darwin_monterey"] }, local windows = { os:: "windows", capabilities+: [self.os] }, local amd64 = { arch:: "amd64", capabilities+: [self.arch] }, @@ -492,7 +511,6 @@ local common_json = import "../common.json"; linux_amd64_ubuntu: linux + amd64 + ubuntu22 + { os_distro:: "ubuntu", os_distro_version:: "22" }, - darwin_amd64: darwin + amd64, darwin_aarch64: darwin + aarch64, windows_amd64: windows + amd64, @@ -504,11 +522,9 @@ local common_json = import "../common.json"; local common = self.deps.mx + self.deps.common_catch_files + self.deps.common_env, local ol_devtoolset = { - packages+: (if self.arch == "aarch64" then { - "00:devtoolset": "==10", # GCC 10.2.1, make 4.2.1, binutils 2.35, valgrind 3.16.1 - } else { - "00:devtoolset": "==11", # GCC 11.2, make 4.3, binutils 2.36, valgrind 3.17 - }), + packages+: { + "00:devtoolset": "==12", # GCC 12.2.1, make 4.3, binutils 2.36, valgrind 3.19 + }, }, linux_amd64: self.linux_amd64_ol7, @@ -523,7 +539,6 @@ local common_json = import "../common.json"; linux_amd64_ubuntu: self.bare.linux_amd64_ubuntu + common, - darwin_amd64: self.bare.darwin_amd64 + common, darwin_aarch64: self.bare.darwin_aarch64 + common, windows_amd64: self.bare.windows_amd64 + common, diff --git a/ci/graal/common.json b/ci/graal/common.json index 86497d63f4..62a81cf1bc 100644 --- a/ci/graal/common.json +++ b/ci/graal/common.json @@ -4,11 +4,11 @@ "Jsonnet files should not include this file directly but use ci/common.jsonnet instead." ], - "mx_version": "7.58.9", + "mx_version": "7.82.2", "COMMENT.jdks": "When adding or removing JDKs keep in sync with JDKs in ci/common.jsonnet", "jdks": { - "galahad-jdk": {"name": "jpg-jdk", "version": "26", "build_id": "jdk-26+7-655", "platformspecific": true, "extrabundles": ["static-libs"]}, + "galahad-jdk": {"name": "jpg-jdk", "version": "25", "build_id": "jdk-25+26-3319", "platformspecific": true, "extrabundles": ["static-libs"]}, "oraclejdk17": {"name": "jpg-jdk", "version": "17.0.7", "build_id": "jdk-17.0.7+8", "platformspecific": true, "extrabundles": ["static-libs"]}, "labsjdk-ce-17": {"name": "labsjdk", "version": "ce-17.0.7+4-jvmci-23.1-b02", "platformspecific": true }, @@ -41,27 +41,24 @@ "labsjdk-ee-21": {"name": "labsjdk", "version": "ee-21.0.2+13-jvmci-23.1-b33", "platformspecific": true }, "labsjdk-ee-21Debug": {"name": "labsjdk", "version": "ee-21.0.2+13-jvmci-23.1-b33-debug", "platformspecific": true }, "labsjdk-ee-21-llvm": {"name": "labsjdk", "version": "ee-21.0.2+13-jvmci-23.1-b33-sulong", "platformspecific": true }, - "graalvm-ee-21": {"name": "graalvm-java21", "version": "23.1.6", "platformspecific": true }, + "graalvm-ee-21": {"name": "graalvm", "version": "21.0.10.0.1-ea.02", "platformspecific": true }, "oraclejdk24": {"name": "jpg-jdk", "version": "24", "build_id": "jdk-24.0.1+9", "platformspecific": true, "extrabundles": ["static-libs"]}, - "oraclejdk25": {"name": "jpg-jdk", "version": "25", "build_id": "jdk-25+30", "platformspecific": true, "extrabundles": ["static-libs"]}, - "labsjdk-ce-25": {"name": "labsjdk", "version": "ce-25+30-jvmci-b01", "platformspecific": true }, - "labsjdk-ce-25Debug": {"name": "labsjdk", "version": "ce-25+30-jvmci-b01-debug", "platformspecific": true }, - "labsjdk-ce-25-llvm": {"name": "labsjdk", "version": "ce-25+30-jvmci-b01-sulong", "platformspecific": true }, - "labsjdk-ee-25": {"name": "labsjdk", "version": "ee-25+30-jvmci-b01", "platformspecific": true }, - "labsjdk-ee-25Debug": {"name": "labsjdk", "version": "ee-25+30-jvmci-b01-debug", "platformspecific": true }, - "labsjdk-ee-25-llvm": {"name": "labsjdk", "version": "ee-25+30-jvmci-b01-sulong", "platformspecific": true }, + "oraclejdk25": {"name": "jpg-jdk", "version": "25", "build_id": "jdk-25.0.2+10", "platformspecific": true, "extrabundles": ["static-libs"]}, + "graalvm-ee-25-ea": {"name": "graalvm-jdk", "version": "25.0.0", "ea": "36", "platformspecific": true }, - "oraclejdk-latest": {"name": "jpg-jdk", "version": "26", "build_id": "jdk-26+7", "platformspecific": true, "extrabundles": ["static-libs"]}, - "labsjdk-ce-latest": {"name": "labsjdk", "version": "ce-26+7-jvmci-b01", "platformspecific": true }, - "labsjdk-ce-latestDebug": {"name": "labsjdk", "version": "ce-26+7-jvmci-b01-debug", "platformspecific": true }, - "labsjdk-ce-latest-llvm": {"name": "labsjdk", "version": "ce-26+7-jvmci-b01-sulong", "platformspecific": true }, - "labsjdk-ee-latest": {"name": "labsjdk", "version": "ee-26+7-jvmci-b01", "platformspecific": true }, - "labsjdk-ee-latestDebug": {"name": "labsjdk", "version": "ee-26+7-jvmci-b01-debug", "platformspecific": true }, - "labsjdk-ee-latest-llvm": {"name": "labsjdk", "version": "ee-26+7-jvmci-b01-sulong", "platformspecific": true } + "oraclejdk-latest": {"name": "jpg-jdk", "version": "25", "build_id": "jdk-25.0.3+9", "platformspecific": true, "extrabundles": ["static-libs"]}, + "labsjdk-ce-latest": {"name": "labsjdk", "version": "ce-25.0.3+9-jvmci-25.1-b18", "platformspecific": true }, + "labsjdk-ce-latestDebug": {"name": "labsjdk", "version": "ce-25.0.3+9-jvmci-25.1-b18-debug", "platformspecific": true }, + "labsjdk-ce-latest-llvm": {"name": "labsjdk", "version": "ce-25.0.3+9-jvmci-25.1-b18-sulong", "platformspecific": true }, + "labsjdk-ee-latest": {"name": "labsjdk", "version": "ee-25.0.3+9-jvmci-25.1-b18", "platformspecific": true }, + "labsjdk-ee-latestDebug": {"name": "labsjdk", "version": "ee-25.0.3+9-jvmci-25.1-b18-debug", "platformspecific": true }, + "labsjdk-ee-latest-llvm": {"name": "labsjdk", "version": "ee-25.0.3+9-jvmci-25.1-b18-sulong", "platformspecific": true } }, + "default_jdks" : ["labsjdk-ee-latest", "labsjdk-ce-latest"], + "eclipse": { "version": "4.26.0", "short_version": "4.26", @@ -70,8 +67,8 @@ "pip": { "ninja_syntax": "==1.7.2", - "lazy-object-proxy": "==1.6.0", - "pylint": "==2.4.4", + "lazy-object-proxy": "==1.10.0", + "pylint": "==3.2.7", "black": "==23.11.0" } } diff --git a/ci/python-bench.libsonnet b/ci/python-bench.libsonnet index beee4444d3..a8f2857110 100644 --- a/ci/python-bench.libsonnet +++ b/ci/python-bench.libsonnet @@ -1,11 +1,11 @@ (import "python-gate.libsonnet") + { - local graal_common = import "graal/common.json", - local common = import "graal/ci/ci_common/common.jsonnet", + local common = import "graal/ci/common.jsonnet", local common_util = import "graal/ci/ci_common/common-utils.libsonnet", local run_spec = import "graal/ci/ci_common/run-spec.libsonnet", local tools = import "graal/ci/ci_common/run-spec-tools.libsonnet", local const = import "constants.libsonnet", + local utils = import "utils.libsonnet", local reports = $.overlay_imports.reports, local exclude = run_spec.exclude, @@ -14,7 +14,6 @@ local platform_spec = run_spec.platform_spec, local evaluate_late = run_spec.evaluate_late, local downloads = self.downloads, - local graalpy_gate = self.graalpy_gate, local os_arch_jdk_mixin = self.os_arch_jdk_mixin, local all_jobs = self.all_jobs, local no_jobs = self.no_jobs, @@ -29,7 +28,8 @@ micro: "micro-graalpython:*", micro_native: "micro-native-graalpython:*", meso: "meso-graalpython:*", - macro: "macro-graalpython:*", + macro: "macro-graalpython:~c-oracledb-load", + macro_oracledb: "macro-graalpython:c-oracledb-load", interop: "interop-graalpython:*", warmup: "python-warmup-graalpython:*", micro_small: "micro-small-graalpython:*", @@ -38,6 +38,8 @@ java_embedding_meso_small: "java-embedding-meso-small:*", jmh: "python-jmh:GRAALPYTHON_BENCH", heap: "heap-graalpython:*", + micro_small_heap: "micro-small-heap-graalpython:*", + micro_native_heap: "micro-native-heap-graalpython:*", }, PY_BENCHMARKS:: { @@ -90,11 +92,15 @@ local environment(os, arch) = self.environment(os, arch) + { BENCH_RESULTS_FILE_PATH: "bench-results.json", PANDAS_REPO_URL: $.overlay_imports.PANDAS_REPO_GIT, + NUMPY_REPO_URL: $.overlay_imports.NUMPY_REPO_GIT, + } + if $.overlay_imports.PIP_EXTRA_INDEX_URL != "" then { PIP_EXTRA_INDEX_URL: $.overlay_imports.PIP_EXTRA_INDEX_URL, - }, + } else {}, + + local pip_index_setup = utils.pip_index_setup($.overlay_imports.PIP_EXTRA_INDEX_URL), local packages(os, arch) = self.packages(os, arch) + { - make: ">=3.83", + make: "==4.3", binutils: "==2.23.2", }, @@ -148,6 +154,7 @@ vm:: [], // public + deploysArtifacts: true, capabilities+: capabilities(self.os, self.arch), downloads: downloads(self.os, self.arch), targets: [self.target] + if self.target == 'bench' then [] else ['bench'], @@ -192,17 +199,18 @@ "--pythonjavadriver-vm-config" else super.vm_config_name, - setup+: [ + setup+: pip_index_setup + [ + // NOTE: logic shared with ci/python-gate.libsonnet, keep in sync // ensure we get graal-enterprise as a hostvm ["git", "clone", $.overlay_imports.GRAAL_ENTERPRISE_GIT, "${BUILD_DIR}/graal-enterprise"], - // force imports the main repository, so we get the relevant suites cloned - ["mx"] + self.vm_info.dy + ["sforceimports"], - // force imports with the env, which may use another suite as the primary and potentially clone other things + // force imports the main repository to get the right graal commit + ["mx", "sforceimports"], + // checkout the matching revision of graal-enterprise repository based on the graal/compiler checkout + ["mx", "--quiet", "--dy", "/graal-enterprise", "checkout-downstream", "compiler", "graal-enterprise", "--no-fetch"], + // force imports with the env, which may clone other things (e.g. substratevm-enterprise-gcs) ["mx"] + self.vm_info.env + self.vm_info.dy + ["sforceimports"], - // force imports the main repository, so we get their versions where it is relevant - ["mx"] + self.vm_info.dy + ["sforceimports"], - // checkout the desired revision of graal-enterprise repository based on the main repositories compiler checkout - ["mx", "--quiet", "-p", "${BUILD_DIR}/graal-enterprise/vm-enterprise", "checkout-downstream", "vm", "vm-enterprise", "--no-fetch"], + // force imports the main repository to get the right graal commit + ["mx", "sforceimports"], // logging ["mx"] + self.vm_info.env + self.vm_info.dy + ["sversions"], // build main repository @@ -238,9 +246,12 @@ downloads: downloads(self.os, self.arch), name: "bisect-benchmark", targets: ['bench'], - logs +: logs(self.os, self.arch), + logs +: logs(self.os, self.arch) + [ + "bisect-benchmark-result.json", + ], + deploysArtifacts: true, packages +: packages(self.os, self.arch) + { - "apache/ant": ">=1.9.4", + "apache/ant": "==1.10.1", libyaml: "==0.2.5", "pip:ninja_syntax": "==1.7.2", "pip:pylint": "==2.4.4", diff --git a/ci/python-gate.libsonnet b/ci/python-gate.libsonnet index dbe350b221..0b1d41aa8e 100644 --- a/ci/python-gate.libsonnet +++ b/ci/python-gate.libsonnet @@ -1,6 +1,5 @@ { - local graal_common = import "graal/ci/common.jsonnet", - local common = import "graal/ci/ci_common/common.jsonnet", + local common = import "graal/ci/common.jsonnet", local common_util = import "graal/ci/ci_common/common-utils.libsonnet", local run_spec = import "graal/ci/ci_common/run-spec.libsonnet", local tools = import "graal/ci/ci_common/run-spec-tools.libsonnet", @@ -27,10 +26,8 @@ // // ----------------------------------------------------------------------------------------------------------------- local jdk_name_to_dict = {[edition]: { - "jdk17"+: common.labsjdk17, - "jdk20"+: common.labsjdk20, - "jdk21"+: common.labsjdk21, - "jdk-latest"+: common.labsjdkLatest, + "jdk21"+: common.jdks["labsjdk-" + edition + "-21"], + "jdk-latest"+: common.jdks["labsjdk-" + edition + "-latest"], } for edition in ['ce', 'ee']}, local jdk_name_to_devkit_suffix = function(name) @@ -45,9 +42,7 @@ amd64 +: common.darwin_amd64 + { capabilities +: ["ram32gb"], }, - aarch64 +: common.darwin_aarch64 + { - capabilities +: ["darwin_bigsur"], - }, + aarch64 +: common.darwin_aarch64, }, windows +: { amd64 +: common.windows_amd64 + { @@ -60,7 +55,7 @@ // this starts with _ on purpose so that it will be evaluated first "_1_os_arch_jdk": function(b) local edition = if (std.objectHasAll(b, 'graalvm_edition')) then b.graalvm_edition else 'ce'; - tools.delete_timelimit(jdk_name_to_dict[edition][b.jdk] + default_os_arch(b.jdk, edition)[b.os][b.arch]) + tools.check_no_timelimit(jdk_name_to_dict[edition][b.jdk] + default_os_arch(b.jdk, edition)[b.os][b.arch]) })), //------------------------------------------------------------------------------------------------------------------ @@ -81,12 +76,11 @@ //------------------------------------------------------------------------------------------------------------------ local DOWNLOADS = { common: { - GRADLE_JAVA_HOME: graal_common.jdks_data["oraclejdk21"], + GRADLE_JAVA_HOME: common.jdks_data["oraclejdk21"], }, linux: { common: { LIBGMP: {name:"libgmp", version:"6.1.0", platformspecific:true}, - NUMPY_BENCHMARKS_DIR: {name: "numpy", version: "1.26.4", platformspecific: false}, PYPY_HOME: {name: "pypy3", version: "3.10-v7.3.12", platformspecific: true}, PYPY_BENCHMARKS_DIR: {name: "pypybenchmarks", version: "84f401a8f55a", platformspecific: false}, }, @@ -103,7 +97,7 @@ }, windows: { common: { - MAVEN_HOME: {name: 'maven', version: '3.3.9', platformspecific: false}, + MAVEN_HOME: {name: 'maven', version: '3.9.10', platformspecific: false}, }, amd64: {}, aarch64: {}, @@ -145,6 +139,7 @@ BISECT_EMAIL_TO_PATTERN: ".*@oracle.com", TRUFFLE_STRICT_OPTION_DEPRECATION: "true", npm_config_registry: $.overlay_imports.npm_config_registry, + CFLAGS: "-ggdb", }, linux: { common: ENV_POSIX + {}, @@ -154,12 +149,15 @@ darwin: { common: ENV_POSIX + { LC_CTYPE: "en_US.UTF-8", + PATH: utils.path_combine(ENVIRONMENT.common.PATH, "$PYTHON3_HOME:$PATH:$MUSL_TOOLCHAIN/bin"), }, amd64: {}, aarch64: {}, }, windows: { common: { + # Gradle: this feature doesn't work on all Windows CI machines + GRADLE_OPTS: "-Dorg.gradle.vfs.watch=false", PATH: "$MAVEN_HOME\\bin;$PATH", }, amd64: {}, @@ -172,7 +170,7 @@ LD_LIBRARY_PATH: "$LIBGMP/lib:$LLVM/lib:$LD_LIBRARY_PATH", FORK_COUNTS_DIRECTORY: "$BUILD_DIR/benchmarking-config/fork-counts", RODINIA_DATASET_ZIP: $.overlay_imports.RODINIA_DATASET_ZIP, - PATH: utils.path_combine(ENVIRONMENT.common.PATH, "$PYTHON3_HOME:$PATH:$MUSL_TOOLCHAIN/bin"), + PATH: utils.path_combine(ENVIRONMENT.common.PATH, "$PATH:$PYTHON3_HOME:$MUSL_TOOLCHAIN/bin"), }, // This is the diff to 'ENVIRONMENT' and meant to be used on OL8 images. @@ -195,6 +193,8 @@ buildslave_ol8: ENVIRONMENT_DIFF_OL8, }, + local pip_index_setup = utils.pip_index_setup($.overlay_imports.PIP_EXTRA_INDEX_URL), + //------------------------------------------------------------------------------------------------------------------ // packages //------------------------------------------------------------------------------------------------------------------ @@ -203,30 +203,32 @@ linux: { common: { "00:devtoolset": "==7", - "01:binutils": ">=2.34", - bzip2: ">=1.0.6", - cmake: ">=3.22.2", - zlib: ">=1.2.11", - lcov: ">=1.11", - libffi: ">=3.2.1", + "01:binutils": "==2.34", + bzip2: "==1.0.6", + cmake: "==3.22.2", + zlib: "==1.2.11", + lcov: "==1.14", + libffi: "==3.2.1", llvm: "==8.0.0", - maven: ">=3.3.9", + maven: "==3.9.10", curl: '==7.50.1', }, amd64: {}, - aarch64: {}, + aarch64: { + maven: "==3.5.3", + }, }, darwin: { common: { coreutils: "", - maven: ">=3.3.9", + maven: "==3.3.9", }, amd64: {}, aarch64: {}, }, windows: { common: { - maven: ">=3.3.9", + maven: "==3.3.9", }, amd64: {}, aarch64: {}, @@ -241,6 +243,8 @@ "graal_dumps/*/*", "bench-results.json", "raw-results.json", + "mxbuild/*/libpythonvm/libpythonvm.so.debug", + "mxbuild/*/GRAALPY_STANDALONE_COMMON/lib/graalpy*/libpython-native.so", ], //------------------------------------------------------------------------------------------------------------------ @@ -253,22 +257,21 @@ timelimit(limit):: task_spec({timelimit: limit}), local tierConfig = { - "tier1": graal_common.frequencies.gate.targets[0], - "tier2": graal_common.frequencies.gate.targets[0], - "tier3": graal_common.frequencies.gate.targets[0], - "tier4": graal_common.frequencies.post_merge.targets[0], + "tier1": "gate", + "tier2": "gate", + "tier3": "gate", }, tierConfig: tierConfig, tier1:: $.target("tier1"), tier2:: $.target("tier2"), tier3:: $.target("tier3"), - post_merge:: $.target("tier4") + task_spec({name_target:: "post_merge"}), + post_merge:: $.target("post-merge") + task_spec({name_target:: "post_merge"}), - bench:: $.target(graal_common.frequencies.bench.targets[0]), - on_demand:: $.target(graal_common.frequencies.on_demand.targets[0]) + task_spec({name_target:: "on_demand"}), - daily:: $.target(graal_common.frequencies.daily.targets[0]), - weekly:: $.target(graal_common.frequencies.weekly.targets[0]), - monthly:: $.target(graal_common.frequencies.monthly.targets[0]), + bench:: $.target("bench"), + on_demand:: $.target("ondemand") + task_spec({name_target:: "on_demand"}), + daily:: $.target("daily"), + weekly:: $.target("weekly"), + monthly:: $.target("monthly"), provide_graalpy_standalone_artifact(name):: task_spec(evaluate_late( // use 2 after _ to make sure we evaluate this right after _1 late eval keys like _1_os_arch_jdk @@ -278,8 +281,8 @@ local jdk_version = self.jdk_version, local artifact_name = name + os + arch, local capabilities = if (self.os == "darwin" && self.arch != "aarch64") then - // for darwin, amd64: set minimum requirement to bigsur - [c for c in super.capabilities if !std.startsWith(c, "darwin")] + ["darwin_bigsur"] + // for darwin, amd64: set minimum requirements + [c for c in super.capabilities if !std.startsWith(c, "darwin")] else super.capabilities, capabilities: capabilities, @@ -341,6 +344,8 @@ task_spec({ environment+: { TAGGED_UNITTEST_PARTIAL: "%d/%d" % [i, num], + RETAGGER_BATCH_NO: "%d" % i, + MX_REPORT_SUFFIX: "_batch_%d" % [i], }, variations+::["batch" + i] }), @@ -372,17 +377,6 @@ packages(os, arch):: get(PACKAGES, os, arch), - local eclipse = task_spec(evaluate_late({ - // late evaluation of the eclipse mixin, conditional import based on platform - // eclipse downloads are not provided for aarch64 - "eclipse": function(builder) - local arch = builder.arch; - if arch == "aarch64" then - {} - else - common.deps.eclipse - })), - logs(os, arch):: LOGS, //------------------------------------------------------------------------------------------------------------------ @@ -417,6 +411,10 @@ python_version: "3.8", targets: [self.target], logs+: $.logs(self.os, self.arch), + catch_files+: [ + // generated by patch in CPython test support + "HEAP DUMP: (?P.+\\.hprof)", + ], // all gates share the same base set of downloads downloads+: $.downloads(self.os, self.arch), // all gates share the same base environment @@ -427,6 +425,7 @@ "--strict-compliance", "--primary", "gate", "--tags", self.tags, "-B=--force-deprecation-as-warning", ] + self.all_suites + self.gate_parameters, ], + deploysArtifacts: true, }), cpython_gate:: base_gate + test_reports + task_spec({ @@ -443,18 +442,19 @@ local jdk_spec = task_spec(evaluate_late({ "select_graalvm_if_older_jdk": function (b) - if b.jdk_version < graal_common.jdks["labsjdk-ee-latest"].jdk_version then + if b.jdk_version < common.jdks["labsjdk-ee-latest"].jdk_version then { downloads+: { - LATEST_JAVA_HOME: graal_common.jdks_data["labsjdk-ce-latest"], + LATEST_JAVA_HOME: common.jdks_data["labsjdk-ce-latest"], + GRAAL_JDK_HOME: common.jdks_data["graalvm-ee-" + b.jdk_version], } } + - graal_common.jdks["graalvm-ee-" + b.jdk_version] + + # Bytecode DSL does not work on JDK21 with optimizing runtime (GR-72424) + # We use OracleJDK as opposed to GraalVM JDK so that it falls back + # to default runtime implicitly + common.jdks["oraclejdk" + b.jdk_version] + { dynamic_imports+:: [], - environment+: { - GRAAL_JDK_HOME: "$JAVA_HOME" - }, } else {} @@ -464,17 +464,29 @@ guard+: { excludes+: ["**.md", "docs/**", "3rd_party_licenses.txt", "scripts/**"], }, - setup+: [ + setup+: pip_index_setup + [ + // force imports the main repository to get the right graal commit ["mx"] + self.mx_parameters + ["sforceimports"], + // logging ["mx"] + self.mx_parameters + self.dy + ["sversions"], ], + on_success+: [ + ["rm", "-rf", "graal_dumps"], + ], }), graalpy_ee_gate:: $.graalpy_gate + task_spec({ setup+: [ + // NOTE: logic shared with ci/python-bench.libsonnet, keep in sync ["git", "clone", $.overlay_imports.GRAAL_ENTERPRISE_GIT, "../graal-enterprise"], - ['mx', '-p', '../graal-enterprise/vm-enterprise', 'checkout-downstream', 'vm', 'vm-enterprise'], - ['mx', '--dynamicimports', '/graal-enterprise', 'sversions'], + // checkout the matching revision of graal-enterprise repository based on the graal/compiler checkout + ["mx", "--quiet", "--dy", "/graal-enterprise", "checkout-downstream", "compiler", "graal-enterprise", "--no-fetch"], + // force imports with the env, which may clone other things (e.g. substratevm-enterprise-gcs) + ["mx", "--env", "native-ee", "sforceimports"], + // force imports the main repository to get the right graal commit + ["mx", "sforceimports"], + // logging + ["mx", "--env", "native-ee", "sversions"], ], }), @@ -483,7 +495,7 @@ dynamic_imports+:: ["/graalpython"], }), - graalpy_eclipse_gate:: $.graalpy_gate + eclipse + jdt, + graalpy_eclipse_gate:: $.graalpy_gate + jdt, unittest_retagger_gate:: $.graalpy_gate + task_spec({ environment+: { @@ -494,15 +506,19 @@ "mx", "graalpytest", "--svm", "--tagged", "--all", "--continue-on-collection-errors", ".", # More workers doesn't help, the job is bottlenecked on all the timeouts in test_asyncio - "-n", "6", + "-n", "4", # The default timeout is very generous to allow for infrastructure flakiness, # but we don't want to auto tag tests that take a long time "--timeout-factor", "0.3", - "--mx-report", "report.json", + "--mx-report", "retagger-report.json", "--exit-success-on-failures", ], ], - logs+: ["report.json"], + logs+: [ + "report.json", + "retagger-report*.json", + "main/retagger-report*.json" + ], }), coverage_gate:: $.graalpy_gate + task_spec({ @@ -514,9 +530,10 @@ $.overlay_imports.BUILDBOT_COMMIT_SERVICE + '?repoName=graal&target=weekly&before-ts=${MAIN_COMMIT_TS}']], ["git", "clone", $.overlay_imports.GRAAL_ENTERPRISE_GIT, "../graal-enterprise"], ['git', '-C', '../graal', 'checkout', '${GRAAL_COMMIT}'], + // NOTE: this will checkout older graalpy. We need to live with that to ensure consistency with graal ['mx', '-p', '../graal/vm', '--dynamicimports', 'graalpython', 'sforceimports'], + // NOTE: jvm-only, so not need to handle substratevm-enterprise-gcs ['mx', '-p', '../graal-enterprise/vm-enterprise', 'checkout-downstream', 'vm', 'vm-enterprise'], - ['git', 'checkout', '${MAIN_REVISION}'], ], run: [ ['mx', 'python-coverage'] + self.coverage_args, @@ -567,7 +584,7 @@ local base_style_gate = $.graalpy_eclipse_gate + task_spec({ dynamic_imports:: ["/truffle"], downloads +: { - EXTRA_JAVA_HOMES: graal_common.jdks_data["labsjdk-ce-21"], + EXTRA_JAVA_HOMES: common.jdks_data["labsjdk-ce-21"], }, packages +: { "pip:pylint": "==2.4.4", diff --git a/ci/utils.libsonnet b/ci/utils.libsonnet index a54031eb0a..e89be0f0c6 100644 --- a/ci/utils.libsonnet +++ b/ci/utils.libsonnet @@ -1,5 +1,5 @@ local const = import 'constants.libsonnet'; -local graal_common = import "graal/ci/common.jsonnet"; +local common = import "graal/ci/common.jsonnet"; { // add a graal option @@ -24,6 +24,24 @@ local graal_common = import "graal/ci/common.jsonnet"; else newPath, + pip_index_setup(extra_index_url):: + local pip_index_from_config_or_env = [ + "python", + "-c", + "import os, subprocess, sys; " + + "cmd = [sys.executable, '-m', 'pip', 'config', 'get', 'global.index-url']; " + + "p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True); " + + "print(p.stdout.strip() if p.returncode == 0 else os.environ.get('PIP_INDEX_URL') or " + + "os.environ.get('PIP_EXTRA_INDEX_URL', ''))", + ]; + (if extra_index_url != "" then [ + ["set-export", "PIP_EXTRA_INDEX_URL", extra_index_url], + ] else []) + [ + // Use the CI Python's configured base index if present. pip config get does not report env + // vars, so preserve Buildbot's PIP_INDEX_URL before falling back to the overlay repository URL. + ["set-export", "PIP_INDEX_URL", pip_index_from_config_or_env], + ], + ensure_notify(builds):: [ b + ( if !std.objectHas(b, "notify_groups") && std.objectHas(b, "targets") && (b.targets == ["gate"] || b.targets == ["post-merge"]) then @@ -36,7 +54,7 @@ local graal_common = import "graal/ci/common.jsonnet"; ensure_no_mx_wrong_build(builds):: [ b + ( - if std.objectHas(b, "setup") && b.jdk_version != graal_common.jdks["labsjdk-ee-latest"].jdk_version then + if std.objectHas(b, "setup") && b.jdk_version != common.jdks["labsjdk-ee-latest"].jdk_version then assert (std.length([step for step in b.setup if std.length(std.find("build", step)) != 0 && std.length(std.find("mx", step)) != 0]) == 0) : b.name + " should not call build in " + b.setup; {} else diff --git a/docs/AGENTS.md b/docs/AGENTS.md new file mode 100644 index 0000000000..ef0201d8ee --- /dev/null +++ b/docs/AGENTS.md @@ -0,0 +1,19 @@ +# docs/ — DOCUMENTATION + +## OVERVIEW +Contributor and user documentation; many repo-wide rules live here. + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Build/test instructions | `contributor/CONTRIBUTING.md` | Primary “how to build/run gates†guide. | +| Runtime internals | `contributor/IMPLEMENTATION_DETAILS.md` | Interpreter design details. | +| Interop rules | `user/Interoperability.md` | Keyword-arg restrictions for foreign calls, etc. | +| Native extensions | `user/Native-Extensions.md` | Guidance on native packages and tooling. | +| Standalone apps | `user/Python-Standalone-Applications.md` | Notes on packaging and limitations. | + +## CONVENTIONS +- Prefer updating docs here rather than duplicating instructions in random READMEs. + +## ANTI-PATTERNS +- Security: follow `SECURITY.md` at repo root; do not instruct users to file public vulnerability issues. diff --git a/docs/contributor/CONTRIBUTING.md b/docs/contributor/CONTRIBUTING.md index 7b5d80b559..612c1554f0 100644 --- a/docs/contributor/CONTRIBUTING.md +++ b/docs/contributor/CONTRIBUTING.md @@ -1,6 +1,6 @@ # Contributing to GraalPy -Thanks for considering to contribute! +Thanks for considering to contribute! To get you started, read about the structure of this implementation. You will need to sign the [Oracle Contributor Agreement](http://www.graalvm.org/community/contributors/) for us to be able to merge your work. @@ -9,6 +9,14 @@ Please also take some time to review our [code of conduct](http://www.graalvm.or ## Getting Started +### Using a Github codespace + +The devcontainer we create sets up a code workspace on launch—the first time you launch the container, you will need a bit of patience. +Then, use the command palette or the File menu and select "Open Workspace from File" and select [/workspace/graalpython.code-workspace](../../../graalpython.code-workspace). +The VSCode window will reload and open GraalPy and all the related Java projects. + +### Setting up on your machine + The first thing you want to do is to set up [`mx`](https://github.com/graalvm/mx.git). This is the build tool we use to develop GraalVM languages. ```shell @@ -55,11 +63,15 @@ This will generate configurations for Eclipse, IntelliJ, and NetBeans so that yo See also the documentation in mx for [setting up your IDE](https://github.com/graalvm/mx/blob/master/docs/IDE.md). If you use another editor (such as VSCode, Emacs, or Neovim) with support for the [Eclipse language server](https://github.com/eclipse/eclipse.jdt.ls) or [Apache NetBeans language server](https://marketplace.visualstudio.com/items?itemName=ASF.apache-netbeans-java), you can also get useable development setups with that, but it's not something we explicitly support. +The checked-in Maven POMs are lightweight facades for quick Java IDE import in editors such as Eclipse, VSCode, or Eglot/JDT-LS. +They are not the full GraalPy build; use `mx ideinit` for the full generated IDE setup and `mx python-jvm` for the build needed to run or test GraalPy. +The facade uses a `graalvm.version` Maven range for the current release train so fresh checkouts resolve the newest available GraalVM artifacts; override `graalvm.version` locally to lock a specific version. + ## Development Layout Besides the source code of the Python interpreter, we have some useful `mx` functions defined under the _mx.graalpython_ directory. As you make changes, you can always test them with `mx python-jvm && mx python`. -Additionally, there are various "gates" that we use on our CI systems to check any code that is committed. +Additionally, there are various "gates" that we use on our CI systems to check any code that is committed. You can run all the gates with the command `mx python-gate` or just some by using `mx python-gate --tags [TAG]`. Interesting gates to run that cover a good chunk of the code things are: @@ -90,7 +102,7 @@ In general, most of these methods should have equivalents in our libs nodes in t If something is missing that is commonly used, we probably have some Node for it somewhere, but it may be a good idea to create a lib node and migrate usages. GraalPy has its own variant of the Argument Clinic preprocessor. -It is activated by: +It is activated by: * extending `PythonXXXClinicBuiltinNode` (e.g. `PythonBinaryClinicBuiltinNode`), * using `@ArgumentClinic` annotations on the built-in node class, * and overriding the `getArgumentClinic` method to return the class that will be generated from the annotations (it will be named the same as the node class plus `ClinicProviderGen` suffix). @@ -127,10 +139,10 @@ If the IDE was initialized properly by using the command mentioned above, the ex Both of these commands also work when you have a `graalpy` executable, e.g. inside a `venv`. -For debugging the C API and native extensions, first make sure you rebuild (`mx clean` first!) graalpything with the environment variable `CFLAGS=-g` set. +For debugging the C API and native extensions, first make sure you rebuild (`mx clean` first!) graalpython with the environment variable `CFLAGS=-g` set. This will keep debug symbols in our C API implementation which should allow you to use `gdb` or [`rr`](https://rr-project.org/) to debug. When you build an SVM image, debugging the entire application is possible, and there are [docs](https://www.graalvm.org/reference-manual/native-image/guides/debug-native-image-process/) to see Java code when inside the native debugger. -Make sure you find and keep the `libpythonvm.so.debug` file around next to your GraalPy build, you can find it somewhere under `graal/sdk/mxbuild`. +Make sure you find and keep the `libpythonvm.so.debug` file around next to your GraalPy build, you can find it under `mxbuild/*/libpythonvm`. ## Advanced Commands to Develop and Debug @@ -149,6 +161,7 @@ mx python-gate --tags python-unittest If some of the tests fail, you can re-run just a single test like this, substituting TEST-SELECTOR with the test you want to run. You can use the whole failed test name including the path as the selector. Note that you can insert `-d` to debug on the Java level or use `--inspect` to debug in the Chrome debugger. +Use `com.oracle.graal.python.runtime.exception.ExceptionUtils.printPythonLikeStackTrace()` in the Java debugger to print the current Python traceback on `stderr`. ```bash mx [-d] graalpytest [--inspect] TEST-SELECTOR @@ -220,6 +233,26 @@ find graalpython -name '*.co' -delete mx punittest com.oracle.graal.python.test.compiler ``` +### CI Unittests + +Most of our internal unittests are also ran on Github workflows. +The `Run CI unittests` (`.github/workflows/ci-unittests.yml`) workflow will execute automatically when you open your PR, synchronize it and mark it as ready. +**Note**: Unittests don't run on draft PRs. + +By default, all gates defined in the `Run CI unittests` `jobs_to_run:` regex will run. +You can run specific tests by manually triggering the `Generate CI Matrix from ci.jsonnet` (`.github/workflows/ci-matrix-gen.yml`) workflow and filling in the `Jobs to run` field.This field MUST be a valid python regex or be left empty to run all gates. + +If you need to update any tags, please use the `Run Weekly unittest retagger` (`.github/workflows/ci-unittests-retagger.yml`) workflow. This sets up the required GitHub-specific environment and ensures that internal tests are not disrupted. Here again, you may use a Python regex to retag only specific platforms. + +The retagger workflow will automatically open a ready-to-merge PR in your fork. + +You can manually check which jobs will be run with your regex by using the `.github/scripts/extract_matrix.py` script. +You will need to have the [sjsonnet](https://github.com/databricks/sjsonnet) binary available. + +```bash +python3 .github/scripts/extract_matrix.py ../sjsonnet ci.jsonnet tier{1-3} {regex} > matrix.json +``` + ## Benchmarking We use the `mx` facilities for benchmarking. @@ -258,14 +291,16 @@ mx benchmark meso:nbody3 \ -Dgraal.MethodFilter=*measure* ``` +For debugging native problems in benchmark runs, there's `BENCHMARK_DEBUG_ARGS` in `mx_graalpython_benchmark.py` to log more stuff for debugging, at the cost of performance. +This is intended for focused reproducer runs on a branch. + ### A note on terminology Note that there may be a little confusion about the configuration names of benchmarks. -#### GraalVM Community Edition and Oracle GraalVM configurations +#### Oracle GraalVM configurations -We have benchmarks for GraalVM Community Edition and Oracle GraalVM. -For historical reasons, these are sometimes referred to in some config files as *CE* and *EE*; *core* and *enterprise*; *graalvm_ce* and *graalvm_ee*; or *graalpython_core* and *graalpython_enterprise*, respectively. +Benchmark CI jobs use Oracle GraalVM configurations. For historical reasons, these are sometimes referred to in config files as *EE*, *enterprise*, *graalvm_ee*, or *graalpython_enterprise*. ### Different GraalVM Python configurations @@ -295,7 +330,7 @@ mx --env ../../graal/vm/mx.vm/ce \ --dynamicimports /vm build ``` -The first command will print some information about the GraalVM configuration that is about to be built, and the second will build it. +The first command will print some information about the GraalVM configuration that is about to be built, and the second will build it. >**IMPORTANT:** The first command should tell you that the `Config name` is `ce_python`, otherwise the next commands will not work. To run the JVM configuration: diff --git a/docs/contributor/GETTING_STARTED.md b/docs/contributor/GETTING_STARTED.md new file mode 100644 index 0000000000..1d5d12cd8b --- /dev/null +++ b/docs/contributor/GETTING_STARTED.md @@ -0,0 +1,99 @@ +# Contributing to GraalPy: getting started + +Thanks for considering contributing to GraalPy. +This page aims at helping you through your first contribution to the project. + +For deep technical details and complete command references, see [CONTRIBUTING.md](./CONTRIBUTING.md). + +If you want help while getting started, join the [GraalVM community Slack](https://www.graalvm.org/slack-invitation/). + +## Quick path for your first contribution + +1. [Pick an issue](#1-pick-an-issue) +2. [Set up your environment](#2-set-up-your-environment) +3. [Make a change](#3-make-a-change) +4. [Run focused checks](#4-run-focused-checks) +5. [Open your Pull Request](#5-open-your-pull-request) + +--- + +## 1. Pick an issue + +Start with something small and well-scoped, for instance, issues labeled [good first issue](https://github.com/oracle/graalpython/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22). + +If there is no issue yet, create one from the [issue templates](https://github.com/oracle/graalpython/issues/new/choose) so the work is tracked and discussed. + +![Issue Form](/docs/contributor/assets/issue_form_selector.png) + +If you think you've found a security vulnerability, do not raise a GitHub issue and follow the instructions in our [security policy](https://github.com/oracle/graalpython/blob/master/SECURITY.md). + +## 2. Set up your environment + +You can contribute using one of the following environments: + +- **GitHub Codespaces** (quickest onboarding): see [Using a GitHub codespace](./CONTRIBUTING.md#using-a-github-codespace) +- **Your local machine**: see [Setting up on your machine](./CONTRIBUTING.md#setting-up-on-your-machine) + +Then do the minimal Git setup: + +```bash +git checkout master +git pull +git checkout -b +``` + +Optionally, after setup: + +```bash +mx ideinit +``` + +## 3. Make a change + +Keep your first change small and easy to review (one issue, one objective, one PR). +Before editing, quickly identify where the code or tests live by checking the project structure in the +[Development Layout](https://github.com/oracle/graalpython/blob/master/docs/contributor/CONTRIBUTING.md#development-layout). + +If you use GitHub Codespaces with GitHub Copilot Pro, you can also run an AI coding agent in an isolated environment with access to Issues, PRs, and CI context. + +## 4. Run focused checks + +Before opening a PR, run tests affected by your changes. + +Common commands: + +- `mx clean`: clean build files +- `mx build`: build GraalPy +- `mx python-svm`: build GraalPy native +- `mx gate --tags python-unittest`: Python unit tests +- `mx gate --tags python-junit`: Java/JUnit tests +- `mx graalpytest ::`: run one targeted Python test + +Example: + +```bash +mx graalpytest graalpython/lib-python/3/test/test_threading.py::test.test_threading.ExceptHookTests.test_excepthook +``` + +If you need a complete list of commands, run `mx help` or check [CONTRIBUTING.md](./CONTRIBUTING.md). + +## 5. Open your pull request + +1. Push your branch to your fork +2. Open a PR against `master` +3. Mark it **Ready for review** when it is ready + +Important: + +- You must sign the [Oracle Contributor Agreement (OCA)](https://www.graalvm.org/community/contributors/) before merge +- CI unit tests run when the PR is ready for review (not in draft) +- Opening a PR early in your fork is fine if you want CI feedback + +--- + +## What to read next + +After your first contribution, continue with: + +- [CONTRIBUTING.md](./CONTRIBUTING.md) for full setup, workflows, and CI details +- [IMPLEMENTATION_DETAILS.md](./IMPLEMENTATION_DETAILS.md) for deeper architecture context diff --git a/docs/contributor/IMPLEMENTATION_DETAILS.md b/docs/contributor/IMPLEMENTATION_DETAILS.md index 8e773edd25..b540380319 100644 --- a/docs/contributor/IMPLEMENTATION_DETAILS.md +++ b/docs/contributor/IMPLEMENTATION_DETAILS.md @@ -170,7 +170,7 @@ safepoint action mechanism can thus be used to kill threads waiting on the GIL. ### High-level C extensions assume reference counting, but on the managed side we want to leverage -Java tracing GC. This creates a mismatch. The approach is to do both, reference +Java's tracing garbage collector (GC). This creates a mismatch. The approach is to do both, reference counting and tracing GC, at the same time. On the native side we use reference counting. The native code is responsible for doing @@ -180,8 +180,8 @@ code is created and when the last reference from the native code is destroyed. On the managed side we rely on tracing GC, so managed references are not ref-counted. For the ref-counting scheme on the native side, we approximate all the managed references -as a single reference, i.e., we increment the refcount when object is referenced from managed -code, and using a `PhantomReference` and reference queue we decrement the refcount when +as a single reference, i.e., we increment the `refcount` when object is referenced from managed +code, and using a `PhantomReference` and reference queue we decrement the `refcount` when there are no longer any managed references (but we do not clean the object as long as `refcount > 0`, because that means that there are still native references to it). @@ -189,56 +189,182 @@ there are no longer any managed references (but we do not clean the object as lo There are two kinds of Python objects in GraalPy: managed and native. +Below is a rough draft of the types and memory layouts involved and how they connect: + +- On the left is the managed (Java) heap +- On the right are memory layouts allocated natively +- At the top are the classes involved with making built-in and pure Python objects available to native code (with PInt as an example) +- At the bottom are the classes involved in making our Java code work when natively allocated memory is passed into GraalPy. + +``` + Managed Heap Native Heap + Stub allocated to represent managed object + +---------------------------+ +-------------------------------+ ++-->| PInt | | struct PyGC_Head { | +| +---------------------------+ | uintptr_t _gc_next | +| | long nativePointer |---------------+ | uintptr_t _gc_prev | +| | PythonObjectReference ref |----+ | | } | +| | BigInteger value | | +------>| struct GraalPyObject { | +| +---------------------------+ | | | Py_ssize_t ob_refcnt | +| | | | PyObject *ob_type | +| | | | int32_t handle_table_index |---+ +| | | | } | | +| | | +-------------------------------+ | +| | | | +| | | | +| | | | +| | | | +| +------------------------+ | | | ++---| PythonObjectReference |<------+ | | + +------------------------+ | | + | long pointer |------------------+ | + | boolean gc | | ++---| boolean freeAtCollect | | +| +------------------------+ | +| | +| +------------------------+ | +|_/\| ReferenceQueue |<---+ | +| \/+------------------------+ | | +| | | +| +---------------------------------------------------+ | +| | HandleContext | | +| +---------------------------------------------------+ index into nativeStubLookup | +| | PythonObjectreference[] nativeStubLookup |-----------------------------------+ +| | HashMap nativeLookup | +| +---------------------------------------------------+ +| | +| +-----------------------+ | Object allocated by native extension ++---| NativeObjectReference | | +--------------------------------+ + +-----------------------+ +-----| struct PyObject { | + +->| |---+ | Py_ssize_t ob_refcnt | + | +-----------------------+ | | PyObject *ob_type | + | +---------------------->| ... | + | +--------------------+ | // extension defined memory | + +->| PythonNativeObject |----------------------------->| | + +--------------------+ +--------------------------------+ + | | + +--------------------+ + +``` + +Managed objects store a pointer to native `GraalPyObject` subinstances when +they go to native, native objects are represented throughout the interpreters +as `PythonAbstractNativeObject`. Both have associated weak references, +`PythonObjectReference` and `NativeObjectReference`, respectively. + #### Managed Objects -Managed objects are allocated in the interpreter. If there is no native code involved, -we do not do anything special and let the Java GC handle them. When a managed object -is passed to a native extension code: - -* We wrap it in `PythonObjectNativeWrapper`. This is mostly in order to provide different -interop protocol: we do not want to expose `toNative` and `asPointer` on Python objects. - -* When NFI calls `toNative`/`asPointer` we: - * Allocate C memory that will represent the object on the native side (including the refcount field) - * Add a mapping of that memory address to the `PythonObjectNativeWrapper` object to a hash map `CApiTransitions.nativeLookup`. - * We initialize the refcount field to a constant `MANAGED_REFCNT` (larger number, because some - extensions like to special case on some small refcount values) - * Create `PythonObjectReference`: a weak reference to the `PythonObjectNativeWrapper`, - when this reference is enqueued (i.e., no managed references exist), we decrement the refcount by - `MANAGED_REFCNT` and if the recount falls back to `0`, we deallocate the native memory of the object, - otherwise we need to wait for the native code to eventually call `Py_DecRef` and make it `0`. - -* When extension code wants to create a new reference, it will call `Py_IncRef`. -In the C implementation of `Py_IncRef` we check if a managed object with -`refcount==MANAGED_REFCNT` wants to increment its refcount. In such case, the native code is -creating a first reference to the managed object, we must make sure to keep the object alive -as long as there are some native references. We set a field `PythonObjectReference.strongReference`, -which will keep the `PythonObjectNativeWrapper` alive even when all other managed references die. - -* When extension code is done with the object, it will call `Py_DecRef`. -In the C implementation of `Py_DecRef` we check if a managed object with `refcount == MANAGED_REFCNT+1` -wants to decrement its refcount to MANAGED_REFCNT, which means that there are no native references -to that object anymore. In such case we clear the `PythonObjectReference.strongReference` field, -and the memory management is then again left solely to the Java tracing GC. +Managed objects are allocated in the interpreter. If there is no native code +involved, we do not do anything special and let the Java GC handle them. If +native code wants to create any kind of object that is implemented as a +built-in (in GraalPy) or in pure Python, we do an upcall and create the managed +object. This object is immediately passed back to native code directly, +and goes through the same transformation as one that was created from Python or +Java code and is, for example, passed as an argument. + +When a managed object is passed to a native extension code: + +* We allocate a `GraalPyObject`, `GraalPyVarObject`, or `GraalPyFloatObject` in + off-heap memory. The native pointer is stored inside the + `PythonAbstractObject`, because pointer identity is relied upon by some + extensions we saw in the wild. (See PythonToNativeNode) + * If the object was a "primitive" (TruffleString, int, long, boolean) we must + first promote the object to an appropriate instance of + `PythonAbstractObject` (e.g. `PString` is the promoted object for + `TruffleString` and `PInt` for Java `int`, `long`, `boolean`). + * For container types (such as tuples, lists), when their elements are + accessed any primitive elements are (like the previous step) boxed into a + `PythonAbstractObject`. + +* When NFI calls `toNative`/`asPointer`, we: + * Allocate a native stub that will represent the object on the native side. + We allocate room for the `refcount` and type pointer to avoid upcalls for + reading those. For some types such as floats, we also store the + double value into native memory to avoid upcalls (see + `FirstToNativeNode`). We also store a custom 32-bit integer into the native + memory with an index into the `nativeStubLookup` array. + * Create `PythonObjectReference`: a weak reference to the + `PythonObjectNativeWrapper`. It is stored in `nativeStubLookup` for + lookup. When this reference is enqueued (meaning no managed references to + the object exist anymore), we decrement the `refcount` by `MANAGED_REFCNT` + and if the recount reached `0`, we deallocate the object's native memory. + Otherwise, we need to wait for the native code to eventually + call `Py_DecRef` and make it `0` (see `AllocateNativeObjectStubNode`). The + field `gc` indicates if this object has a GC header prepended to the + pointer. The field `freeAtCollect` indicates this pointer can be free'd + immediately when the reference is enqueued. + * Initialize the `refcount` field to a constant `MANAGED_REFCNT` (larger + number, because some extensions like to special case on some small + `refcount` values) + * Set the high bit of the allocated pointer to quickly identify stubs + in native code. This allows us to make small + modifications to the existing macros for checking types and refcounts in + the Python C API. + +* When extension code creates a new reference, it calls `Py_IncRef`. + In the C implementation of `Py_IncRef`, we check if a managed + object with `refcount==MANAGED_REFCNT` wants to increment its `refcount`. + To ensure the object remains alive while native references exist, + we set the `PythonObjectReference.strongReference` field which keeps + the `PythonObjectNativeWrapper` alive even after all managed references are gone. + +* When extension code is done with the object, it calls `Py_DecRef`. In the + C implementation of `Py_DecRef`, we check if a managed object with + `refcount == MANAGED_REFCNT+1` wants to decrement its `refcount` to `MANAGED_REFCNT`, + which means that there are no native references to that object anymore. + We then clear the `PythonObjectReference.strongReference` field, and the + memory management is then again left solely to the Java tracing GC. #### Native Objects -Native objects allocated using `PyObject_GC_New` in the native code are backed by native memory -and may never be passed to managed code (as a return value of extension function or as an argument -to some C API call). If a native object is not made available to managed code, it is just reference -counted as usual, where `Py_DecRef` call that reaches `0` will deallocate the object. If a native -object is passed to managed code: +Native objects allocated using `PyObject_GC_New` in the native code are backed +by native memory and may never be passed to managed code (as a return value of +extension function or as an argument to some C API call). If a native object is +not made available to managed code, it is just reference counted as usual, +and when `Py_DecRef` reduces its count to `0`, it deallocates the object. + -* We increment the refcount of the native object by `MANAGED_REFCNT` +If a native object is passed to managed code (see +CApiTransitions.createAbstractNativeObject): +* We increment the `refcount` of the native object by `MANAGED_REFCNT` * We create: * `PythonAbstractNativeObject` Java object to mirror it on the managed side - * `NativeObjectReference`, a weak reference to the `PythonAbstractNativeObject`. -* Add mapping: native object address => `NativeObjectReference` into hash map `CApiTransitions.nativeLookup` + * `NativeObjectReference`, a weak reference to the + `PythonAbstractNativeObject` which will be enqueued when it is no longer + referenced from managed objects. +* Add mapping: native object address => `NativeObjectReference` into hash map + `CApiTransitions.nativeLookup` * Next time we just fetch the existing wrapper and don't do any of this -* When `NativeObjectReference` is enqueued, we decrement the refcount by `MANAGED_REFCNT` - * If the refcount falls to `0`, it means that there are no references to the object even from - native code, and we can destroy it. If it does not fall to `0`, we just wait for the native - code to eventually call `Py_DecRef` that makes it fall to `0`. +* When `NativeObjectReference` is enqueued, we decrement the `refcount` by + `MANAGED_REFCNT` + * If the `refcount` falls to `0`, it means that there are no references to the + object even from native code, and we can destroy it. If it does not fall to + `0`, we just wait for the native code to eventually call `Py_DecRef` that + makes it fall to `0`. + +##### Memory Pressure + +Since native allocations are not visible to the JVM, we can run into trouble if +an application allocates only small managed objects that have large amounts of +off-heap memory attached. In such cases, the GC does not see any memory +pressure and may not collect the objects with associated native memory. +To address this, we track off-heap allocations and count the allocated bytes. +In order to correctly account for free'd memory, we prepend a header that +stores the allocated size in the Python APIs memory management functions. + +When we exceed a configurable threshold (`MaxNativeMemory`), we force a full Java GC, +which also triggers a native Python cycle collection (see below). Unfortunately +not all extensions use that API, so we *also* run a background thread +that watches process RSS (see the `BackgroundGCTask*` context options). If +RSS increases too quickly and we are allocating weak references for native objects, +we force GCs more frequently. + +For things that allocate GPU memory this is still not enough, since there are no +APIs we can use to get GPU allocation rate across platforms. For PyTorch (for example) +we apply a patch that forces a GC whenever a CUDA allocation fails and retries. +Additionally, some extensions cause such a high rate of stub allocations that polling +weak references on a lower priority background thread was too slow. To address this, +we also poll during transitions to prevent our handle table from growing too rapidly. #### Weak References @@ -263,7 +389,7 @@ The high level solution is that when we see a "dead" cycle going through an obje which may be, however, referenced from managed), we fully replicate the object graphs (and the cycle) on the managed side (refcounts of native objects in the cycle, which were not referenced from managed yet, will get new `NativeObjectReference` -created and refcount incremented by `MANAGED_REFCNT`). Managed objects already refer +created and `refcount` incremented by `MANAGED_REFCNT`). Managed objects already refer to the `PythonAbstractNativeObject` wrappers of the native objects (e.g., some Python container with managed storage), but we also make the native wrappers refer to whatever their referents are on the Java side (we use `tp_traverse` to find their referents). @@ -279,17 +405,17 @@ count them into this limit. Let us call this limit *weak to strong limit*. After this, if the objects on the managed side (the managed objects or `PythonAbstractNativeObject` mirrors of native objects) are garbage, eventually Java GC will collect them. This will push their references to the reference queue. When polled from the queue (`CApiTransitions#pollReferenceQueue`), -we decrement the refcount by `MANAGED_REFCNT` (no managed references anymore) and -if their refcount falls to `0`, they are freed - as part of that, we call the +we decrement the `refcount` by `MANAGED_REFCNT` (no managed references anymore) and +if their `refcount` falls to `0`, they are freed - as part of that, we call the `tp_clear` slot for native objects, which should call `Py_CLEAR` for their references, -which does `Py_DecRef` - eventually all objects in the cycle should fall to refcount `0`. +which does `Py_DecRef` - eventually all objects in the cycle should fall to `refcount` `0`. -*Example: managed object `o1` has refcount `MANAGED_REFCNT+1`: `MANAGED_REFCNT` representing all managed +*Example: managed object `o1` has `refcount` `MANAGED_REFCNT+1`: `MANAGED_REFCNT` representing all managed references, and `+1` for some native object `o2` referencing it. Native object `o2` has refcount `MANAGED_REFCNT`, because it is referenced only from managed (from `o1`). Both `o1` and `o2` form a cycle that was already transformed to managed during cycle GC. -The reference queue processing will subtract `MANAGED_REFCNT` from `o1`'s refcount making it `1`. -Then the reference queue processing will subtract `MANAGED_REFCNT` from `o2`'s refcount making it fall +The reference queue processing will subtract `MANAGED_REFCNT` from `o1`'s `refcount` making it `1`. +Then the reference queue processing will subtract `MANAGED_REFCNT` from `o2`'s `refcount` making it fall to `0` - this triggers the `tp_clear` of `o2`, which should subtract the final `1` from `o1`'s refcount.* If some of the managed objects are not garbage, and they passed back to native code, diff --git a/docs/contributor/assets/issue_form_selector.png b/docs/contributor/assets/issue_form_selector.png new file mode 100644 index 0000000000..d0c8cc64c5 Binary files /dev/null and b/docs/contributor/assets/issue_form_selector.png differ diff --git a/docs/site/01-docs.md b/docs/site/01-docs.md deleted file mode 100644 index 5d6452bfe4..0000000000 --- a/docs/site/01-docs.md +++ /dev/null @@ -1,26 +0,0 @@ ---- -layout: docs -title: Documentation -permalink: docs/ ---- - -{% gfm_docs ../user/README.md %} -{% gfm_docs ../user/Python-Runtime.md %} -{% gfm_docs ../user/Performance.md %} -{% gfm_docs ../user/Python-on-JVM.md %} - -

-Python Context Options -

-Below are the options you can set on contexts for GraalPy. -{% python_options ../../graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java %} - -{% gfm_docs ../user/Native-Images-with-Python.md %} -{% gfm_docs ../user/Python-Standalone-Applications.md %} -{% gfm_docs ../user/Interoperability.md %} -{% gfm_docs ../user/Embedding-Build-Tools.md %} -{% gfm_docs ../user/Embedding-Permissions.md %} -{% gfm_docs ../user/Tooling.md %} -{% gfm_docs ../user/Troubleshooting.md %} - -{% copy_assets ../user/assets %} diff --git a/docs/site/01-jvm-developers.md b/docs/site/01-jvm-developers.md new file mode 100644 index 0000000000..945ed1c361 --- /dev/null +++ b/docs/site/01-jvm-developers.md @@ -0,0 +1,505 @@ +--- +layout: base +permalink: jvm-developers/ +audience_identifier: jvm +--- + +
+
+
+
+

Embed Python in JVM Applications with GraalPy

+
+
+
+ access icon +
+
+

Python Packages in Java

+
+
+
Use Python packages directly in Java, Kotlin, or Scala
+
+
+
+
+ speed icon +
+
+

Jython Upgrade Path

+
+
+
Upgrade Jython projects to Python 3
+
+
+
+
+ upgrade icon +
+
+

JVM Scripting with Python

+
+
+
Script JVM applications with Python
+
+
+
+
+
+
+
+ +
+
+
+
+

How to Get Started

+
+
Add GraalPy as a dependency to your JVM application, or go straight to the starter project.
+
+
+
+
+

Without Python Dependencies

+
+
+
+ + +
+
+ +
+
+
+{%- highlight groovy -%} +dependencies { + implementation("org.graalvm.polyglot:polyglot:{{ site.language_version }}") + implementation("org.graalvm.polyglot:python:{{ site.language_version }}") +} +{%- endhighlight -%} + +
+
+
+
+{%- highlight java -%} +import org.graalvm.polyglot.Context; + +try (Context context = Context.newBuilder() + .allowAllAccess(true) // See documentation for options + .build()) { + context.eval("python", "print('Hello from GraalPy!')"); +} +{%- endhighlight -%} + +
+
+
+
+
+
+

With Python Dependencies

+
+
+
+ + +
+
+ +
+
+
+{%- highlight groovy -%} +plugins { + id "org.graalvm.python" version "{{ site.language_version}}" +} + +dependencies { + implementation("org.graalvm.python:python-embedding:{{ site.language_version }}") +} + +graalPy { + packages = ["pyfiglet==1.0.2"] +} +{%- endhighlight -%} + +
+
+
+
+{%- highlight java -%} +import org.graalvm.polyglot.Context; +import org.graalvm.python.embedding.GraalPyResources; + +try (Context context = GraalPyResources.contextBuilder().build()) { + context.eval("python", """ + from pyfiglet import Figlet + f = Figlet(font='slant') + print(f.renderText('Hello from GraalPy!')) + """); +} +{%- endhighlight -%} + +
+
+
+
+
+
+
+
+
+ + + + +
+
+
+
+

Guides

+
+
+
+ book icon + +
Embed GraalPy in Java Applications
+ +
+
+ book icon + +
Use GraalPy with Maven or Gradle in a Java SE Application
+ +
+
+ book icon + +
Freeze Transitive Python Dependencies for Reproducible Builds
+ +
+
+ book icon + +
Use GraalPy with Spring Boot
+ +
+
+
+
+ book icon + +
Use GraalPy with Micronaut
+ +
+
+ book icon + +
Manually Install Python Packages
+ +
+
+ book icon + +
Use GraalPy Maven Plugin to Install Python Native Extensions
+ +
+
+
+
+
+
+
+ +
+
+
+
+

Demos

+
+
+
+ book icon + +
Debug Python Scripts in VS Code with GraalPy
+ +
+
+ book icon + +
GraalPy OpenAI Starter
+ +
+
+ book icon + +
GraalPy JBang QRCode
+ +
+
+
+
+ book icon + +
SVG Charts with GraalPy and Spring Boot
+ +
+
+ book icon + +
SVG Charts with GraalPy and Micronaut
+ +
+
+
+
+
+
+
+ +
+
+
+
+

Videos

+
+
+ + IntelliJ 2025 thumbnail +
+ play button +
+ +
+
+
+

Tips and Tricks for GraalVM and Graal Languages

+
+
+
In this session, Fabio Niephaus from the GraalVM team shows his favourite tips and tricks for using GraalPy and other Graal Languages in IntelliJ IDEA. He also shows how to use IntelliJ IDEA as a multi-language IDE. Language injections and support for various debugging protocols make it easy to embed and debug code written in languages like Python in Java applications. +
+
+
+
+
+
+ + Jfokus 2025 thumbnail +
+ play button +
+ +
+
+
+

Supercharge your Java Applications with Python!
Jfokus'25

+
+
+
Projects such as LangChain4j, Spring AI, and llama3.java got the Java community very excited about AI in the last year. + The Python ecosystem also provides many powerful packages for data science, machine learning, and more. + Wouldn't it be cool if you, as a Java developer, could benefit from this, too? +
+ In this talk, we show how you can get started with GraalPy and use packages from the Python ecosystem. + We also show some live demos and preview upcoming features that will improve the interaction between Java and native extensions that ship with popular Python packages. +
+
+
+
+
+
+
+
diff --git a/docs/site/01-python-developers.md b/docs/site/01-python-developers.md new file mode 100644 index 0000000000..4e0afdc721 --- /dev/null +++ b/docs/site/01-python-developers.md @@ -0,0 +1,244 @@ +--- +layout: base +permalink: python-developers/ +audience_identifier: python +--- + +
+
+
+
+

Build and Run Python Applications with GraalPy

+
+
+
+ compatibility icon +
+
+

High-Performance Python

+
+
+
Speed up Python applications with the Graal JIT compiler
+
+
+
+
+ binary icon +
+
+

Single-Binary Packaging

+
+
+
Package Python applications as a single binary
+
+
+
+
+ code icon +
+
+

Java Interoperability

+
+
+
Use Java libraries in Python applications
+
+
+
+
+
+
+
+ +
+ +
+
+
+

Install or Download

+
+
+ GraalPy is available for multiple platforms in two variants: Native (for a compact download size and smaller footprint) and JVM (for full Java interoperability). Distributions based on Oracle GraalVM provide the best performance and advanced features and are released under the GFTC license. Distributions based on GraalVM Community Edition, released under the OSI-approved UPL license, are available on GitHub. + See Choosing a GraalPy Distribution for guidance on selecting the appropriate runtime. +
+
+
+
+
+{%- highlight bash -%} +# Latest GraalPy release +pyenv install graalpy-{{ site.language_version }} +pyenv shell graalpy-{{ site.language_version }} + +# On Windows (pyenv-win), provide platform-specific names +pyenv install graalpy-{{ site.language_version }}-windows-amd64 +pyenv shell graalpy-{{ site.language_version }}-windows-amd64 + +# Latest development build of GraalPy +pyenv install graalpy-dev +pyenv shell graalpy-dev +{%- endhighlight -%} +
+
+
+ + pyenv badge + +
+
+
+
+
+{%- highlight bash -%} +# Install GraalPy with uv (uv selects GraalPy by Python language version) +uv python install graalpy-3.12 + +# Create a virtual environment with GraalPy +uv venv --python graalpy-3.12 +{%- endhighlight -%} +
+
+
+ + uv badge + +
+
+
+
+
+ {%- highlight yml -%} +steps: +- uses: actions/checkout@v4 +- uses: actions/setup-python@v5 + with: + python-version: 'graalpy-{{ site.language_version }}' +- run: python my_script.py + {%- endhighlight -%} +
+
+ +
+ github icon +
+ +
+
+ + + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + +
VersionLinux (aarch64)Linux (amd64)macOS (aarch64)Windows (amd64)
+ {{ site.language_version }} + + download icon + + download icon + + download icon + + download icon +
Latest early access build + download icon + + download icon + + download icon + + download icon +
+
+
+ download icon +
+
+
+
+
+
+ + +
+
+
+
+

Guides

+
+
+
+ book icon + +
Choose the Right GraalPy Runtime Distribution
+ +
+
+ book icon + +
Package Python as Standalone Applications
+ +
+
+
+
+ book icon + +
Use GraalPy as a Standalone Python Runtime
+ +
+
+
+
+
+
+
diff --git a/docs/site/02-downloads.md b/docs/site/02-downloads.md deleted file mode 100644 index fcf6ca3795..0000000000 --- a/docs/site/02-downloads.md +++ /dev/null @@ -1,396 +0,0 @@ ---- -layout: base -title: Downloads -permalink: downloads/ -published: false ---- - -
-
-
-
-

Download GraalPy from Maven Central

-
-
- Have a Java application? -
-
-You can extend it with Python code or leverage packages from the Python ecosystem. GraalPy is available on Maven Central and can be added as a dependency to your Maven or Gradle project as — see setup instructions. -
-
-
-
-
-
- -
-
-
-
-

Download Standalone Distributions of GraalPy

-
-
- Do you want to test your Python application or package on GraalPy? -
-
- To test Python code on GraalPy, a standalone distribution is available for different platforms and in two different kinds: Native (for compact download and footprint) and JVM (for full Java interoperability). We recommend the distributions based on Oracle GraalVM for best performance and advanced features (released under the GFTC license). Distributions based on GraalVM Community Edition (released under the OSI-approved UPL license) are available on GitHub. Standalone distributions are also available via pyenv, pyenv-win, and setup-python: -
-
-
-
-
- {%- highlight bash -%} -# Latest GraalPy release -pyenv install graalpy-{{ site.language_version }} -pyenv shell graalpy-{{ site.language_version }} - -# Latest EA build of GraalPy -pyenv install graalpy-dev -pyenv shell graalpy-dev - {%- endhighlight -%} -
-
-
- pyenv and pyenv-win -
-
-
-
-
- {%- highlight yml -%} -steps: -- uses: actions/checkout@v4 -- uses: actions/setup-python@v5 - with: - python-version: 'graalpy-{{ site.language_version }}' -- run: python my_script.py - {%- endhighlight -%} -
-
- -
- github icon -
- -
-
-
-
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
VersionKindLinux (aarch64)Linux (amd64)macOS (aarch64)macOS (amd64)Windows (amd64)
- {{ site.language_version }}
- other versions - 		Native - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
JVM - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Latest early access buildNative - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
JVM - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-
- binary icon -
-
-
GraalPy on Oracle GraalVM is free to use in production and free to redistribute, at no cost, under the GraalVM Free Terms and Conditions.
-
-
-
-
diff --git a/docs/site/02-jvm-developers-docs.md b/docs/site/02-jvm-developers-docs.md new file mode 100644 index 0000000000..8c969c3572 --- /dev/null +++ b/docs/site/02-jvm-developers-docs.md @@ -0,0 +1,39 @@ +--- +layout: docs +permalink: jvm-developers/docs/ +audience_identifier: jvm +title: Documentation +--- + +# Documentation for JVM Developers + +**For JVM developers who need to use Python libraries from their JVM applications or migrate from legacy Jython code.** + +You do not need to install GraalPy separately - you can use GraalPy directly in Java with Maven or Gradle. +This lets you call Python libraries like NumPy, pandas, or any PyPI package from your Java application. +GraalPy also provides a migration path from Jython 2.x to Python 3.x with better performance and maintained Java integration capabilities. + +{% gfm_docs ../user/Version-Compatibility.md %} + +{% gfm_docs ../user/Platform-Support.md %} + +These guides cover everything you need to know: + +{% gfm_docs ../user/Embedding-Getting-Started.md %} +{% gfm_docs ../user/Embedding-Build-Tools.md %} +{% gfm_docs ../user/Embedding-Permissions.md %} +{% gfm_docs ../user/Embedding-Native-Extensions.md %} +{% gfm_docs ../user/Interoperability.md %} +{% gfm_docs ../user/Native-Images-with-Python.md %} +{% gfm_docs ../user/Python-on-JVM.md %} + +

+Python Context Options +

+Below are the options you can set on contexts for GraalPy. +{% python_options ../../graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java %} + +{% gfm_docs ../user/Test-Tiers.md %} +{% gfm_docs ../user/Troubleshooting.md %} + +{% copy_assets ../user/assets %} diff --git a/docs/site/02-python-developers-docs.md b/docs/site/02-python-developers-docs.md new file mode 100644 index 0000000000..be9e34bc9e --- /dev/null +++ b/docs/site/02-python-developers-docs.md @@ -0,0 +1,30 @@ +--- +layout: docs +permalink: python-developers/docs/ +audience_identifier: python +title: Documentation +--- + +# Documentation for Python Developers + +**You want to use GraalPy instead of the standard Python from python.org.** + +Install GraalPy on your machine and use it like any Python interpreter. +You get better performance, the ability to compile to native binaries, and access to the GraalVM ecosystem. + +{% gfm_docs ../user/Version-Compatibility.md %} + +{% gfm_docs ../user/Platform-Support.md %} + +These guides cover everything you need to know: + +{% gfm_docs ../user/Standalone-Getting-Started.md %} +{% gfm_docs ../user/Python-Standalone-Applications.md %} +{% gfm_docs ../user/Native-Extensions.md %} +{% gfm_docs ../user/Interoperability.md %} +{% gfm_docs ../user/Performance.md %} +{% gfm_docs ../user/Tooling.md %} + +{% gfm_docs ../user/Test-Tiers.md %} + +{% copy_assets ../user/assets %} diff --git a/docs/site/03-compatibility.md b/docs/site/03-compatibility.md deleted file mode 100644 index c20529daef..0000000000 --- a/docs/site/03-compatibility.md +++ /dev/null @@ -1,660 +0,0 @@ ---- -layout: base -title: Compatibility -permalink: compatibility/ ---- - - - - - - - -
-
-
-
-

GraalPy: Package Compatibility

- - GraalPy is compatible with many packages for Data Science and Machine Learning, including the popular PyTorch, NumPy, and Huggingface Transformers. - To try a package, pick any version and only if you run into problems, consult our table below to see if there is a version that may work better. - -
-
-

GraalPy 24.2

-

GraalPy 24.1

-
-
-
-
-
-
- - - -
-
-
-
-

-
-
- -
-

Numeric Computing

-
-
-
We test NumPy across multiple versions and know of multiple deployments where it brings numeric computing to Java.
-
-
-
- -
-

Scientific Computing

-
-
-
SciPy's rich library for scientific computing is just a package download away.
-
-
-
- -
-

Data Processing

-
-
-
Thanks to Arrow, Pandas on GraalPy can run multi-threaded while avoiding unneccessary data copies.
-
-
-
-
-
- -
-

Models for any Task

-
-
-
The Huggingface transformers library works on GraalPy with its huge library of language, vision, and audio models.
-
-
-
- -
-

Training and Inference

-
-
-
Train models and run inference on GraalPy with PyTorch, taking full advantage of the latest techniques and accellerator hardware.
-
-
-
- -
-

Agentic Workflows

-
-
-
With Autogen and GraalPy you can write agentic workflows and use Java code to create tools for AI Agents.
-
-
-
-
-
-
-
-
-
-
-
-
To ensure GraalPy is compatible with common Python packages, - the GraalPy team conducts compatibility testing and creates scripts to build and patch many - of the top packages on PyPI plus some more that are of special interest to us, including - libraries and frameworks such as NumPy, Pandas, and Django.
-
Compatibility testing ensures that - developers can leverage GraalPy's powerful capabilities in their existing applications. - It also enables developers to use GraalPy to create more efficient and productive applications in the areas of - machine learning, data analysis, and web development using their familiar Python - toolsets.
-
Many more Python packages than are on this list work on GraalPy. - If there is a package you are interested in that you cannot find here, chances are that it - might just work. If it does not, please reach out to us on GitHub
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Compatible: loading...
-
- Currently Untested: loading...
-
-
-
Currently - Incompatible: loading...
-
Not - Supported: loading...
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

Python Packages

-
-
- -
-
-
- - -
-
-
-
- - - - - - - - - - -
NameVersionNotes
-
-
-
- - -
-
- - -
-
-
-
-
-
-
diff --git a/docs/site/03-jvm-developers-compatibility.md b/docs/site/03-jvm-developers-compatibility.md new file mode 100644 index 0000000000..5c4267791b --- /dev/null +++ b/docs/site/03-jvm-developers-compatibility.md @@ -0,0 +1,626 @@ +--- +layout: base +permalink: jvm-developers/compatibility/ +audience_identifier: jvm +title: Compatibility +--- + + + + + + + +
+
+
+
+

Package Compatibility

+

GraalPy is compatible with many packages for data science and machine learning, including the popular PyTorch, NumPy, and Huggingface Transformers.

+
+
+
+
+ +
+
+
+
+
+
+ +
+

Numeric Computing

+
+
+
We test NumPy across multiple versions and know of multiple deployments where it brings numeric computing to Java.
+
+
+
+ +
+

Scientific Computing

+
+
+
SciPy's rich library for scientific computing is just a package download away.
+
+
+
+ +
+

Data Processing

+
+
+
Thanks to Arrow, Pandas on GraalPy can run multi-threaded while avoiding unneccessary data copies.
+
+
+
+
+
+ +
+

Models for any Task

+
+
+
The Huggingface transformers library works on GraalPy with its huge library of language, vision, and audio models.
+
+
+
+ +
+

Training and Inference

+
+
+
Train models and run inference on GraalPy with PyTorch, taking full advantage of the latest techniques and accellerator hardware.
+
+
+
+ +
+

Agentic Workflows

+
+
+
With Autogen and GraalPy you can write agentic workflows and use Java code to create tools for AI Agents.
+
+
+
+
+
+
+
+ +
+
+
+
+
+

Compatibility per GraalPy Release

+
+
+

GraalPy 25.0

+

GraalPy 24.2

+

GraalPy 24.1

+
+
+
+

Over 600 Python packages tested for compatibility with GraalPy

+
+
+
+
+
+
Compatible: loading...
+
+ Currently Untested: loading...
+
+
+
Currently + Incompatible: loading...
+
Not + Supported: loading...
+
+
+
+
+
+
+
+
+
+ +
+
+
+
+
+ info icon +
Many more Python packages work on GraalPy than are listed here. If there is a package you are interested in that is not included, chances are that it might just work. If it does not, feel free to create an issue for us on GitHub.
+
+
+
+ +
+
+
+ + +
+
+
+
+ + + + + + + + + + +
NameVersionNotes
+
+
+
+ + +
+
+ + +
+
+
+
+
+
+
diff --git a/docs/site/03-python-developers-compatibility.md b/docs/site/03-python-developers-compatibility.md new file mode 100644 index 0000000000..0ba5cc70e4 --- /dev/null +++ b/docs/site/03-python-developers-compatibility.md @@ -0,0 +1,626 @@ +--- +layout: base +permalink: python-developers/compatibility/ +audience_identifier: python +title: Compatibility +--- + + + + + + + +
+
+
+
+

Package Compatibility

+

GraalPy is compatible with many packages for data science and machine learning, including the popular PyTorch, NumPy, and Huggingface Transformers.

+
+
+
+
+ +
+
+
+
+
+
+ +
+

Numeric Computing

+
+
+
We test NumPy across multiple versions and know of multiple deployments where it brings numeric computing to Java.
+
+
+
+ +
+

Scientific Computing

+
+
+
SciPy's rich library for scientific computing is just a package download away.
+
+
+
+ +
+

Data Processing

+
+
+
Thanks to Arrow, Pandas on GraalPy can run multi-threaded while avoiding unneccessary data copies.
+
+
+
+
+
+ +
+

Models for any Task

+
+
+
The Huggingface transformers library works on GraalPy with its huge library of language, vision, and audio models.
+
+
+
+ +
+

Training and Inference

+
+
+
Train models and run inference on GraalPy with PyTorch, taking full advantage of the latest techniques and accellerator hardware.
+
+
+
+ +
+

Agentic Workflows

+
+
+
With Autogen and GraalPy you can write agentic workflows and use Java code to create tools for AI Agents.
+
+
+
+
+
+
+
+ +
+
+
+
+
+

Compatibility per GraalPy Release

+
+
+

GraalPy 25.0

+

GraalPy 24.2

+

GraalPy 24.1

+
+
+
+

Over 600 Python packages tested for compatibility with GraalPy

+
+
+
+
+
+
Compatible: loading...
+
+ Currently Untested: loading...
+
+
+
Currently + Incompatible: loading...
+
Not + Supported: loading...
+
+
+
+
+
+
+
+
+
+ +
+
+
+
+
+ info icon +
Many more Python packages work on GraalPy than are listed here. If there is a package you are interested in that is not included, chances are that it might just work. If it does not, feel free to create an issue for us on GitHub.
+
+
+
+ +
+
+
+ + +
+
+
+
+ + + + + + + + + + +
NameVersionNotes
+
+
+
+ + +
+
+ + +
+
+
+
+
+
+
diff --git a/docs/site/CNAME b/docs/site/CNAME new file mode 100644 index 0000000000..4cfdd3e7eb --- /dev/null +++ b/docs/site/CNAME @@ -0,0 +1 @@ +graalpy.org diff --git a/docs/site/Gemfile b/docs/site/Gemfile index 2c11ff519e..51c5774c7f 100644 --- a/docs/site/Gemfile +++ b/docs/site/Gemfile @@ -1,8 +1,8 @@ -source "https://rubygems.org" +source ENV.fetch("RUBYGEMS_MIRROR", "https://rubygems.org") gem "jekyll", "~> 4.3.4" -gem "graal-languages-jekyll-theme" +gem "graal-languages-jekyll-theme", git: "https://github.com/graalvm/graal-languages-jekyll-theme.git", branch: "main" group :jekyll_plugins do gem "jekyll-relative-links" diff --git a/docs/site/Gemfile.lock b/docs/site/Gemfile.lock index d7ae358a10..76a1a94a19 100644 --- a/docs/site/Gemfile.lock +++ b/docs/site/Gemfile.lock @@ -1,60 +1,74 @@ +GIT + remote: https://github.com/graalvm/graal-languages-jekyll-theme.git + revision: 1e8d5b675768ea158684474ef7a32a6ed8ce9baf + branch: main + specs: + graal-languages-jekyll-theme (0.2.0) + jekyll (~> 4.3) + GEM remote: https://rubygems.org/ specs: Ascii85 (2.0.1) - addressable (2.8.7) - public_suffix (>= 2.0.2, < 7.0) - afm (0.2.2) - async (2.23.0) + addressable (2.9.0) + public_suffix (>= 2.0.2, < 8.0) + afm (1.0.0) + async (2.37.0) console (~> 1.29) fiber-annotation - io-event (~> 1.9) + io-event (~> 1.11) metrics (~> 0.12) - traces (~> 0.15) - bigdecimal (3.1.8) + traces (~> 0.18) + benchmark (0.5.0) + bigdecimal (3.3.1) coderay (1.1.3) colorator (1.1.0) - concurrent-ruby (1.3.4) - console (1.29.3) + concurrent-ruby (1.3.6) + console (1.34.3) fiber-annotation fiber-local (~> 1.1) json - csv (3.3.0) + csv (3.3.5) em-websocket (0.5.3) eventmachine (>= 0.12.9) http_parser.rb (~> 0) - ethon (0.16.0) + ethon (0.18.0) ffi (>= 1.15.0) + logger eventmachine (1.2.7) - ffi (1.17.0-x86_64-linux-gnu) + ffi (1.17.4-arm64-darwin) + ffi (1.17.4-x86_64-linux-gnu) fiber-annotation (0.2.0) fiber-local (1.1.0) fiber-storage - fiber-storage (1.0.0) + fiber-storage (1.0.1) forwardable-extended (2.6.0) - google-protobuf (4.28.3-x86_64-linux) + google-protobuf (4.34.1-arm64-darwin) bigdecimal - rake (>= 13) - graal-languages-jekyll-theme (0.1.0) - jekyll (~> 4.3) + rake (~> 13.3) + google-protobuf (4.34.1-x86_64-linux-gnu) + bigdecimal + rake (~> 13.3) hashery (2.1.2) - html-proofer (5.0.10) + html-proofer (5.2.1) addressable (~> 2.3) async (~> 2.1) + benchmark (~> 0.5) nokogiri (~> 1.13) pdf-reader (~> 2.11) rainbow (~> 3.0) typhoeus (~> 1.3) yell (~> 2.0) zeitwerk (~> 2.5) - http_parser.rb (0.8.0) - httparty (0.22.0) + http_parser.rb (0.8.1) + httparty (0.24.2) csv mini_mime (>= 1.0.0) multi_xml (>= 0.5.2) - i18n (1.14.6) + i18n (1.14.8) concurrent-ruby (~> 1.0) - io-event (1.9.0) + io-console (0.8.2) + io-event (1.11.2) jekyll (4.3.4) addressable (~> 2.4) colorator (~> 1.0) @@ -73,75 +87,85 @@ GEM webrick (~> 1.7) jekyll-relative-links (0.7.0) jekyll (>= 3.3, < 5.0) - jekyll-sass-converter (3.0.0) - sass-embedded (~> 1.54) - jekyll-seo-tag (2.8.0) + jekyll-sass-converter (3.1.0) + sass-embedded (~> 1.75) + jekyll-seo-tag (2.9.0) jekyll (>= 3.8, < 5.0) jekyll-watch (2.2.1) listen (~> 3.0) - json (2.10.1) - kramdown (2.4.0) - rexml + json (2.19.5) + kramdown (2.5.2) + rexml (>= 3.4.4) kramdown-parser-gfm (1.1.0) kramdown (~> 2.0) liquid (4.0.4) - listen (3.9.0) + listen (3.10.0) + logger rb-fsevent (~> 0.10, >= 0.10.3) rb-inotify (~> 0.9, >= 0.9.10) + logger (1.7.0) mercenary (0.4.0) method_source (1.1.0) - metrics (0.12.1) + metrics (0.15.0) mini_mime (1.1.5) - multi_xml (0.7.1) - bigdecimal (~> 3.1) - nokogiri (1.18.3-x86_64-linux-gnu) + multi_xml (0.9.1) + bigdecimal (>= 3.1, < 5) + nokogiri (1.19.3-arm64-darwin) + racc (~> 1.4) + nokogiri (1.19.3-x86_64-linux-gnu) racc (~> 1.4) pathutil (0.16.2) forwardable-extended (~> 2.6) - pdf-reader (2.14.1) + pdf-reader (2.15.1) Ascii85 (>= 1.0, < 3.0, != 2.0.0) - afm (~> 0.2.1) + afm (>= 0.2.1, < 2) hashery (~> 2.0) ruby-rc4 ttfunk - pry (0.14.2) + pry (0.16.0) coderay (~> 1.1) method_source (~> 1.0) - public_suffix (6.0.1) + reline (>= 0.6.0) + public_suffix (7.0.5) racc (1.8.1) - rack (3.1.8) + rack (3.2.6) rainbow (3.1.1) - rake (13.2.1) + rake (13.4.2) rb-fsevent (0.11.2) rb-inotify (0.11.1) ffi (~> 1.0) - rexml (3.3.9) - rouge (4.5.1) + reline (0.6.3) + io-console (~> 0.5) + rexml (3.4.4) + rouge (4.7.0) ruby-rc4 (0.1.5) safe_yaml (1.0.5) - sass-embedded (1.81.0-x86_64-linux-gnu) - google-protobuf (~> 4.28) + sass-embedded (1.99.0-arm64-darwin) + google-protobuf (~> 4.31) + sass-embedded (1.99.0-x86_64-linux-gnu) + google-protobuf (~> 4.31) siteleaf (2.3.0) httparty (>= 0.16.0) jekyll (>= 1.4.1) rack terminal-table (3.0.2) unicode-display_width (>= 1.1.1, < 3) - traces (0.15.2) + traces (0.18.2) ttfunk (1.8.0) bigdecimal (~> 3.1) - typhoeus (1.4.1) - ethon (>= 0.9.0) + typhoeus (1.6.0) + ethon (>= 0.18.0) unicode-display_width (2.6.0) - webrick (1.9.0) + webrick (1.9.2) yell (2.2.2) - zeitwerk (2.7.2) + zeitwerk (2.7.5) PLATFORMS + arm64-darwin-24 x86_64-linux DEPENDENCIES - graal-languages-jekyll-theme + graal-languages-jekyll-theme! html-proofer http_parser.rb (~> 0.6.0) jekyll (~> 4.3.4) diff --git a/docs/site/_config.yml b/docs/site/_config.yml index cc9685fd8f..76f3a59edf 100644 --- a/docs/site/_config.yml +++ b/docs/site/_config.yml @@ -1,11 +1,17 @@ -baseurl: "/python" -url: "https://graalvm.org" +baseurl: "" +url: "https://graalpy.org" github: "oracle/graalpython" -language_version: 24.2.1 +language_version: 25.0.3 +python_version: 3.12 name: GraalPy - permalink: pretty +audiences: + - identifier: jvm + name: JVM + - identifier: python + name: Python + plugins: - jekyll-relative-links - jekyll-seo-tag diff --git a/docs/site/_plugins/graalpy_wheels.txt b/docs/site/_plugins/graalpy_wheels.txt index 8136d81c2e..e4c9a544d1 100644 --- a/docs/site/_plugins/graalpy_wheels.txt +++ b/docs/site/_plugins/graalpy_wheels.txt @@ -52,3 +52,46 @@ watchfiles-0.21.0-graalpy311-graalpy242_311_native-manylinux_2_28_x86_64.whl xxhash-3.4.1-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl xxhash-3.4.1-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl xxhash-3.4.1-graalpy311-graalpy242_311_native-win_amd64.whl + +# GraalPy 25.0 +contourpy-1.2.1-graalpy312-graalpy250_312_native-macosx_13_0_arm64.whl +contourpy-1.2.1-graalpy312-graalpy250_312_native-manylinux_2_26_aarch64.whl +contourpy-1.2.1-graalpy312-graalpy250_312_native-manylinux_2_27_x86_64.whl +httptools-0.6.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +httptools-0.6.1-graalpy312-graalpy250_312_native-manylinux1_x86_64.manylinux_2_5_x86_64.whl +httptools-0.6.1-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +jiter-0.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +jiter-0.5.0-graalpy312-graalpy250_312_native-manylinux_2_28_aarch64.whl +jiter-0.5.0-graalpy312-graalpy250_312_native-manylinux_2_28_x86_64.whl +kiwisolver-1.4.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +kiwisolver-1.4.5-graalpy312-graalpy250_312_native-manylinux_2_24_aarch64.whl +kiwisolver-1.4.5-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.whl +kiwisolver-1.4.5-graalpy312-graalpy250_312_native-win_amd64.whl +numpy-2.2.4-graalpy312-graalpy250_312_native-macosx_13_0_arm64.whl +numpy-2.2.4-graalpy312-graalpy250_312_native-manylinux_2_27_aarch64.whl +numpy-2.2.4-graalpy312-graalpy250_312_native-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl +numpy-2.2.4-graalpy312-graalpy250_312_native-win_amd64.whl +oracledb-3.4.2-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +oracledb-3.4.2-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +oracledb-3.4.2-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl +polyleven-0.8-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +polyleven-0.8-graalpy312-graalpy250_312_native-manylinux1_x86_64.manylinux_2_5_x86_64.whl +polyleven-0.8-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +polyleven-0.8-graalpy312-graalpy250_312_native-win_amd64.whl +psutil-5.9.8-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +psutil-5.9.8-graalpy312-graalpy250_312_native-manylinux2010_x86_64.manylinux_2_12_x86_64.whl +psutil-5.9.8-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +psutil-5.9.8-graalpy312-graalpy250_312_native-win_amd64.whl +ujson-5.10.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +ujson-5.10.0-graalpy312-graalpy250_312_native-manylinux_2_24_aarch64.whl +ujson-5.10.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl +ujson-5.10.0-graalpy312-graalpy250_312_native-win_amd64.whl +uvloop-0.19.0-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +uvloop-0.19.0-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl +watchfiles-0.21.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +watchfiles-0.21.0-graalpy312-graalpy250_312_native-manylinux_2_28_aarch64.whl +watchfiles-0.21.0-graalpy312-graalpy250_312_native-manylinux_2_28_x86_64.whl +xxhash-3.4.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl +xxhash-3.4.1-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl +xxhash-3.4.1-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl +xxhash-3.4.1-graalpy312-graalpy250_312_native-win_amd64.whl diff --git a/docs/site/assets/img/python/devoxx2024-cover.png b/docs/site/assets/img/python/devoxx2024-cover.png index c3980a6d39..0667f737a7 100644 Binary files a/docs/site/assets/img/python/devoxx2024-cover.png and b/docs/site/assets/img/python/devoxx2024-cover.png differ diff --git a/docs/site/assets/img/python/intellij2025-cover.png b/docs/site/assets/img/python/intellij2025-cover.png new file mode 100644 index 0000000000..efc12931e6 Binary files /dev/null and b/docs/site/assets/img/python/intellij2025-cover.png differ diff --git a/docs/site/assets/img/python/jfocus2025-cover.png b/docs/site/assets/img/python/jfocus2025-cover.png index 50d98b313f..c92048182b 100644 Binary files a/docs/site/assets/img/python/jfocus2025-cover.png and b/docs/site/assets/img/python/jfocus2025-cover.png differ diff --git a/docs/site/assets/img/python/pyenv-badge.svg b/docs/site/assets/img/python/pyenv-badge.svg new file mode 100644 index 0000000000..ec1dc8f212 --- /dev/null +++ b/docs/site/assets/img/python/pyenv-badge.svg @@ -0,0 +1,10 @@ + + + + + + pyenv + + + + diff --git a/docs/site/assets/img/python/uv-badge.svg b/docs/site/assets/img/python/uv-badge.svg new file mode 100644 index 0000000000..685deac379 --- /dev/null +++ b/docs/site/assets/img/python/uv-badge.svg @@ -0,0 +1,10 @@ + + + + + + uv + + + + diff --git a/docs/site/docs-redirect.md b/docs/site/docs-redirect.md new file mode 100644 index 0000000000..efb05173c2 --- /dev/null +++ b/docs/site/docs-redirect.md @@ -0,0 +1,15 @@ +--- +layout: docs +permalink: docs/ +redirect_to: jvm-developers/docs/ +--- + + + + + +

Redirecting to the documentation for JVM Developers...

diff --git a/docs/site/index.md b/docs/site/index.md index b544cbd82c..3bda1c1391 100644 --- a/docs/site/index.md +++ b/docs/site/index.md @@ -1,101 +1,14 @@ --- layout: base --- -
+
+
-

A high-performance embeddable Python 3 runtime for Java

-
- Quickstart - Guides -
-
-
- Python icon -
-
-
-
-
-
- - -
-
-
-
-

Benefits

-
-
-
- access icon -
-
-

Python for Java

-
-
-
Load and use Python packages directly in Java
-
-
-
-
- compatibility icon -
-
-

Python 3 Compatible

-
-
-
Compatible with many Python packages, including popular AI and Data Science libraries
-
-
-
-
- speed icon -
-
-

Fastest Python on the JVM

-
-
-
Graal JIT compiles Python for native code speed
-
-
-
-
-
-
- upgrade icon -
-
-

Modern Python for the JVM

-
-
-
GraalPy provides an upgrade path for Jython users
-
-
-
-
- code icon -
-
-

Script Java with Python

-
-
-
Extend applications with Python scripts that interact with Java
-
-
-
-
- binary icon -
-
-

Simple distribution

-
-
-
Package Python applications as a single binary with GraalVM Native Image
-
+

A high-performance embeddable Python 3 runtime

@@ -103,285 +16,59 @@ layout: base
- -
+
-
-
-

How to Get Started

-
-
You have the option to extend your Java application with Python, or go straight to the starter project
-
-
-
-

1. Add GraalPy as a dependency from Maven Central

-
-
-
-
-

1. Add GraalPy as a dependency from Maven Central

-
- {%- highlight xml -%} - - org.graalvm.polyglot - polyglot - {{ site.language_version }} - - - org.graalvm.polyglot - python - {{ site.language_version }} - pom - - {%- endhighlight -%} -
-
- -
-
-
-
-
-

or

-
- {%- highlight groovy -%} -implementation("org.graalvm.polyglot:polyglot:{{ site.language_version }}") -implementation("org.graalvm.polyglot:python:{{ site.language_version }}") - {%- endhighlight -%} -
-
- -
-
-
-

2. Embed Python code in Java

-
-
-
-
-

2. Embed Python code in Java

-
- {%- highlight java -%} +
+
+
+ +

Embed Python in JVM Applications

+
+{%- highlight java -%} import org.graalvm.polyglot.Context; -try (Context context = Context.create()) { +try (Context context = Context.newBuilder() + .allowAllAccess(true) // See documentation for options + .build()) { context.eval("python", "print('Hello from GraalPy!')"); } - {%- endhighlight -%} -
-
- -
-
-
-

3. Add GraalPy plugins for additional Python packages (optional)

-
-
-
-
-

3. Add GraalPy plugins for additional Python packages (optional)

-
- {%- highlight xml -%} - - org.graalvm.python - graalpy-maven-plugin - {{ site.language_version }} - - - - - - pyfiglet==1.0.2 - - - - process-graalpy-resources - - - - - {%- endhighlight -%} -
-
- -
-
-
-
-
-

or

-
- {%- highlight groovy -%} -plugins { - id("org.graalvm.python") version "{{ site.language_version }}" -} - -graalPy { - packages = setOf("pyfiglet==1.0.2") -} - {%- endhighlight -%} -
-
- -
-
-
-
-
-
-
- -
-
-
-
-

Guides

-
-
-
- book icon - -
Use GraalPy with Maven or Gradle in a Java SE Application
- -
-
- book icon - -
Use GraalPy with Spring Boot
- -
-
- book icon - -
Use GraalPy with Micronaut
- -
-
- book icon - -
Manually Install Python Packages and Files
- -
-
-
-
- book icon - -
Migrate from Jython to GraalPy
- -
-
- book icon - -
Freeze Transitive Python Dependencies for Reproducible Builds
- -
-
- book icon - -
Use GraalPy Maven Plugin to Install Python Native Extensions
- -
-
+{%- endhighlight -%} +
+
    +
  • Use Python packages directly in Java, Kotlin, or Scala
    • +
  • Upgrade Jython projects to Python 3
    • +
  • Control permissions for Python code from full host access to fully sandboxed
    • +
  • Script JVM applications with Python
    • +
-
-
-
-
- -
-
-
-
-

Demos

-
-
-
- book icon - -
GraalPy OpenAI Starter
- -
-
- book icon - -
GraalPy JBang QRCode
- -
-
-
-
- book icon - -
SVG Charts with GraalPy and Spring Boot
- -
-
- book icon - -
SVG Charts with GraalPy and Micronaut
- -
-
-
-
-
-
-
+
+ +

Build and Run Python Applications

+
+{%- highlight bash -%} +$ pyenv install graalpy-{{ site.language_version }} +$ pyenv shell graalpy-{{ site.language_version }} - -
-
-
-
-

Videos

-
-
- - Jfokus 2025 thumbnail -
- play button -
- -
-
-
-

Supercharge your Java Applications with Python!
Jfokus'25

-
-
-
Projects such as LangChain4j, Spring AI, and llama3.java got the Java community very excited about AI in the last year. - The Python ecosystem also provides many powerful packages for data science, machine learning, and more. - Wouldn't it be cool if you, as a Java developer, could benefit from this, too? -
- In this talk, we show how you can get started with GraalPy and use packages from the Python ecosystem. - We also show some live demos and preview upcoming features that will improve the interaction between Java and native extensions that ship with popular Python packages. -
-
-
-
-
-
- - Devoxx 2024 thumbnail -
- play button -
- -
-
-
-

Supercharge your Java Applications with Python!
Devoxx'24

-
-
-
The Python ecosystem provides many powerful packages for data science, machine learning, and more, that you can now leverage in Java. - Get started by adding GraalPy as a dependency to your Java project. - There are also Maven and Gradle plugins for GraalPy that help you install additional Python packages. - In this presentation, we also show live demos that illustrate different use cases, such as a Spring Boot application that visualizes data with Python, Python running on JBang!, a Java application scripted with Python, and more. -
-
-
+$ python3 -c "import sys; print(sys.implementation.name)" +graalpy +$ python3 -m timeit "'-'.join(str(n) for n in range(100))" +500000 loops, best of 5: 757 nsec per loop +{%- endhighlight -%} +
+
    +
  • Speed up Python applications with the Graal JIT
    • +
  • Compatible with many Python AI and data science packages
    • +
  • Package Python applications as a single binary
    • +
  • Use Java libraries in Python applications
    • +
+ + + +
diff --git a/docs/site/module_results/python-module-testing-v250.csv b/docs/site/module_results/python-module-testing-v250.csv new file mode 100644 index 0000000000..57b613718c --- /dev/null +++ b/docs/site/module_results/python-module-testing-v250.csv @@ -0,0 +1,605 @@ +absl-py,2.2.2,0,98.75 +aif360,0.6.1,2,0.00 +aiodns,3.2.0,2,0.00 +aiofiles,24.1.0,0,99.07 +aiohttp,3.11.18,1,0.00 +aiohttp-cors,0.8.1,1,23.23 +aioredis,2.0.1,2,0.00 +aiorwlock,1.5.0,2,0.00 +aiosignal,1.3.2,0,100.00 +alembic,1.15.2,0,100.00 +aliyun-python-sdk-core,2.16.0,2,0.00 +altair,5.5.0,2,0.00 +annotated-types,0.7.0,0,100.00 +ansible-core,2.18.5,2,0.00 +anthropic,0.63.0,2,0.00 +anyio,4.9.0,2,0.00 +appdirs,1.4.4,0,100.00 +APScheduler,3.11.0,1,0.00 +argcomplete,3.6.2,1,33.33 +arrow,1.3.0,0,99.95 +asgiref,3.8.1,0,98.61 +asn1crypto,1.5.1,2,0.00 +astor,0.8.1,0,96.36 +astroid,3.3.9,2,0.00 +astropy,7.0.1,2,0.00 +asttokens,3.0.0,0,97.50 +async-timeout,5.0.1,0,88.24 +async_generator,1.10,0,88.37 +asyncpg,0.30.0,1,0.77 +atomicwrites,1.4.1,0,100.00 +attrs,25.3.0,0,93.85 +autoflake,2.3.1,0,100.00 +autopep8,2.3.2,1,0.00 +awscli,1.40.2,0,99.70 +azure-common,1.1.28,0,100.00 +azure-identity,1.21.0,2,0.00 +azure-storage-blob,12.25.1,2,0.00 +backcall,0.2.0,0,100.00 +backoff,2.2.1,0,78.99 +bandit,1.8.3,1,0.00 +base58,2.1.1,0,100.00 +bcrypt,4.3.0,0,100.00 +beautifulsoup4,4.13.4,0,100.00 +biopython,1.85,2,0.00 +black,25.1.0,0,91.54 +bleach,6.2.0,0,100.00 +blessed,1.21.0,1,0.00 +blinker,1.9.0,0,80.00 +blis,1.3.0,2,0.00 +bokeh,3.7.2,2,0.00 +boto3,1.38.3,2,0.00 +botocore,1.38.3,1,0.00 +bottle,0.13.3,0,100.00 +build,1.2.2.post1,0,97.96 +bump2version,1.0.1,0,97.63 +CacheControl,0.14.2,1,0.00 +cachetools,5.5.2,0,100.00 +catalogue,2.0.10,0,100.00 +catboost,1.2.8,2,0.00 +category-encoders,2.8.1,1,0.00 +celery,5.5.2,2,0.00 +Cerberus,1.3.7,0,100.00 +certifi,2025.4.26,0,100.00 +cffi,1.17.1,2,0.00 +chardet,5.2.0,0,100.00 +charset-normalizer,3.4.1,0,80.00 +check-manifest,0.50,0,100.00 +circuitbreaker,2.1.3,0,100.00 +click,8.1.8,0,100.00 +cliff,4.9.1,2,0.00 +cloudpickle,3.1.1,1,0.00 +cmaes,0.11.1,2,0.00 +cmd2,2.5.11,0,76.59 +codecov,2.1.13,0,100.00 +colorama,0.4.6,0,100.00 +coloredlogs,15.0.1,1,0.00 +colorful,0.5.6,0,100.00 +colorlog,6.9.0,0,100.00 +commonmark,0.9.1,0,100.00 +ConfigArgParse,1.7,0,100.00 +configobj,5.0.9,0,100.00 +configparser,7.2.0,0,100.00 +confluent-kafka,2.10.0,2,0.00 +contourpy,1.3.2,0,99.88 +cookiecutter,2.6.0,0,99.73 +coverage,7.8.0,1,0.00 +coveralls,4.0.1,1,0.00 +cryptography,44.0.2,0,100.00 +cssselect,1.3.0,0,100.00 +cycler,0.12.1,0,100.00 +cymem,2.0.11,0,100.00 +Cython,3.0.12,1,0.00 +dask,2025.4.1,1,0.00 +dataclasses-json,0.6.7,0,99.70 +datasets,3.5.0,2,0.00 +dateparser,1.2.1,0,99.99 +DateTime,5.5,1,0.00 +DAWG-Python,0.7.2,2,0.00 +debugpy,1.8.14,2,0.00 +decorator,5.2.1,2,0.00 +deepdiff,8.4.1,2,0.00 +defusedxml,0.7.1,0,95.06 +Deprecated,1.2.18,0,89.33 +dice-ml,0.11,2,0.00 +dill,0.4.0,1,0.00 +discord.py,2.5.2,1,0.00 +diskcache,5.6.3,1,0.00 +distlib,0.3.9,0,77.73 +distributed,2025.4.1,1,0.00 +distro,1.9.0,0,100.00 +Django,5.2,2,0.00 +django-filter,25.1,0,96.53 +django-model-utils,5.0.0,1,0.00 +djangorestframework,3.16.0,0,99.42 +dnspython,2.7.0,0,98.87 +docker,7.1.0,2,0.00 +docopt,0.6.2,0,100.00 +docutils,0.21.2,0,99.82 +dohq-artifactory,1.0.1,0,100.00 +ecdsa,0.19.1,1,0.00 +einops,0.8.1,2,0.00 +elasticsearch,9.0.0,2,0.00 +email-validator,2.2.0,0,100.00 +emoji,2.14.1,0,100.00 +entrypoints,0.4,0,100.00 +eventlet,0.39.1,1,0.00 +execnet,2.1.1,1,0.00 +fake-useragent,2.2.0,1,0.00 +Faker,37.1.0,0,99.81 +fastapi,0.115.12,0,99.12 +feedparser,6.0.11,1,0.00 +filelock,3.18.0,1,0.00 +fiona,1.10.1,2,0.00 +fire,0.7.0,1,0.00 +flake8,7.2.0,2,0.00 +flake8-bandit,4.1.1,0,87.98 +flake8-bugbear,24.12.12,1,0.00 +flake8-comprehensions,3.16.0,0,100.00 +flake8-polyfill,1.0.2,2,0.00 +FLAML,2.3.4,2,0.00 +Flask,3.1.0,0,100.00 +flask-cors,5.0.1,2,0.00 +Flask-Login,0.6.3,0,87.72 +Flask-OpenTracing,2.0.0,0,100.00 +Flask-SQLAlchemy,3.1.1,0,97.35 +Flask-WTF,1.2.2,0,100.00 +flatbuffers,25.2.10,2,0.00 +fonttools,4.57.0,1,0.00 +fpdf2,2.8.3,1,0.00 +freezegun,1.5.1,0,99.27 +frozenlist,1.6.0,2,0.00 +fsspec,2025.3.2,0,90.70 +future,1.0.0,0,97.91 +fuzzywuzzy,0.18.0,0,98.59 +gast,0.6.0,0,98.15 +gensim,4.3.3,1,0.00 +geojson,3.2.0,0,100.00 +geopandas,1.0.1,1,0.00 +geopy,2.4.1,1,48.87 +gevent,25.4.2,1,0.00 +gitdb,4.0.12,0,100.00 +gitdb2,4.0.2,1,66.67 +GitPython,3.1.44,1,6.74 +google-api-core,2.24.2,1,0.00 +google-api-python-client,2.168.0,0,99.07 +google-auth,2.39.0,1,0.00 +google-auth-httplib2,0.2.0,0,100.00 +google-auth-oauthlib,1.2.2,0,97.14 +google-cloud-bigquery,3.31.0,1,0.00 +google-cloud-storage,3.1.0,0,99.57 +google-pasta,0.2.0,0,76.15 +googleapis-common-protos,1.70.0,0,100.00 +gpustat,1.1.1,1,0.00 +graphviz,0.20.3,0,99.73 +greenlet,3.2.1,1,0.00 +grpcio,1.71.0,2,0.00 +gssapi,1.9.0,0,100.00 +gunicorn,23.0.0,1,0.00 +h11,0.16.0,0,100.00 +h5py,3.13.0,1,0.00 +horovod,0.28.1,1,43.75 +html2text,2025.4.15,0,100.00 +html5lib,1.1,0,99.99 +httpcore,1.0.9,1,0.00 +httplib2,0.22.0,2,0.00 +httptools,0.6.4,0,100.00 +httpx,0.28.1,0,89.99 +huggingface-hub,0.30.2,2,0.00 +humanfriendly,10.0,1,27.78 +humanize,4.12.2,0,99.84 +hvac,2.3.0,0,88.28 +hypothesis,6.131.9,1,0.00 +idna,3.10,0,100.00 +imageio,2.37.0,0,90.91 +imbalanced-learn,0.13.0,2,0.00 +implicit,0.7.2,1,0.00 +importlib-metadata,8.7.0,0,100.00 +importlib-resources,6.5.2,0,100.00 +inflection,0.5.1,0,100.00 +iniconfig,2.1.0,0,100.00 +invoke,2.2.0,1,0.00 +ipdb,0.13.13,0,95.45 +ipykernel,6.29.5,2,0.00 +ipython,9.2.0,0,87.20 +ipywidgets,8.1.6,2,0.00 +iso8601,2.1.0,0,100.00 +isodate,0.7.2,0,100.00 +isort,6.0.1,1,0.00 +itsdangerous,2.2.0,0,100.00 +jaeger-client,4.8.0,2,0.00 +jax,0.6.0,2,0.00 +jedi,0.19.2,1,0.00 +jeepney,0.9.0,0,92.50 +jieba,0.42.1,2,0.00 +Jinja2,3.1.6,0,97.69 +jiter,0.9.0,0,100.00 +jmespath,1.0.1,0,100.00 +joblib,1.4.2,1,0.00 +jq,1.8.0,0,100.00 +json5,0.12.0,0,100.00 +jsonpickle,4.0.5,1,0.00 +jsonschema,4.23.0,1,0.00 +jupyter-client,8.6.3,1,0.00 +jupyter-core,5.7.2,0,100.00 +jupyterlab,4.4.1,1,0.00 +kafka-python,2.1.5,0,99.93 +kazoo,2.10.0,2,0.00 +keras,3.9.2,2,0.00 +Keras-Preprocessing,1.1.2,1,53.33 +keyboard,0.13.5,0,99.36 +keyring,25.6.0,0,99.16 +kiwisolver,1.4.8,0,100.00 +krb5,0.7.1,0,100.00 +kubernetes,32.0.1,0,99.64 +langchain,0.3.24,1,1.89 +lazy-object-proxy,1.11.0,0,97.17 +libclang,18.1.1,2,0.00 +librosa,0.11.0,1,0.00 +lightfm,1.17,2,0.00 +lightgbm,4.6.0,1,0.00 +livereload,2.7.1,0,100.00 +lizard,1.17.27,0,99.88 +llvmlite,0.44.0,2,0.00 +loguru,0.7.3,0,96.93 +logzero,1.7.0,2,0.00 +lxml,5.4.0,0,94.00 +m2r2,0.3.3.post2,2,0.00 +Mako,1.3.10,0,100.00 +Markdown,3.8,0,100.00 +MarkupSafe,3.0.2,0,98.72 +marshmallow,4.0.0,0,99.91 +matplotlib,3.10.1,0,99.32 +matplotlib-inline,0.1.7,2,0.00 +mccabe,0.7.0,0,93.75 +mcp,1.12.4,2,0.00 +memory-profiler,0.61.0,1,0.00 +mistune,3.1.3,0,100.00 +mkdocs,1.6.1,0,95.86 +mkdocstrings,0.29.1,0,80.00 +mlflow,2.22.0,2,0.00 +mock,5.2.0,0,97.82 +more-itertools,10.7.0,0,99.40 +moto,5.1.4,0,98.97 +moviepy,2.1.2,1,0.00 +msgpack,1.1.0,1,35.83 +msrest,0.7.1,0,88.57 +multidict,6.4.3,1,0.00 +multiprocess,0.70.18,2,0.00 +murmurhash,1.0.12,2,0.00 +mypy,1.15.0,1,0.00 +mypy-extensions,1.1.0,0,100.00 +mysql-connector-python,9.3.0,1,0.00 +mysqlclient,2.2.7,0,99.03 +myst-parser,4.0.1,0,99.45 +natsort,8.4.0,1,0.00 +nbconvert,7.16.6,0,99.38 +nbformat,5.10.4,1,0.00 +nest-asyncio,1.6.0,0,100.00 +netaddr,1.3.0,1,0.00 +netCDF4,1.7.2,1,0.00 +netifaces,0.11.0,0,100.00 +networkx,3.4.2,1,0.00 +nibabel,5.3.2,1,0.00 +nltk,3.9.1,0,99.26 +notebook,7.4.1,1,0.00 +nox,2025.2.9,2,0.00 +numba,0.61.2,2,0.00 +numexpr,2.10.2,2,0.00 +numpy,2.2.4,0,99.53 +numpydoc,1.8.0,0,92.54 +oauthlib,3.2.2,0,99.85 +oci,2.150.2,2,0.00 +oldest-supported-numpy,2023.12.21,0,100.00 +onnx,1.17.0,1,0.00 +onnxmltools,1.13.0,2,0.00 +onnxruntime,1.22.1,1,0.00 +openai,1.76.0,2,0.00 +opencensus,0.11.4,2,0.00 +opencensus-context,0.1.3,2,0.00 +opencv-python,4.11.0.86,1,0.00 +opencv-python-headless,4.11.0.86,1,0.00 +openpyxl,3.1.5,0,99.96 +opentracing,2.4.0,2,0.00 +opt-einsum,3.4.0,2,0.00 +optree,0.15.0,2,0.00 +optuna,4.3.0,1,0.00 +oracledb,3.1.0,2,0.00 +orbit-ml,1.1.4.9,1,0.00 +orjson,3.10.18,1,0.00 +packaging,25.0,0,100.00 +paho-mqtt,2.1.0,0,96.36 +pandas,2.2.3,0,93.17 +papermill,2.6.0,0,94.70 +paramiko,3.5.1,0,99.48 +parse,1.20.2,0,100.00 +parso,0.8.4,0,94.08 +pathlib2,2.3.7.post1,0,100.00 +pathos,0.3.4,1,0.00 +pathspec,0.12.1,0,100.00 +pathy,0.11.0,0,100.00 +patsy,1.0.1,0,97.28 +pbr,6.1.1,1,0.00 +peewee,3.17.9,0,99.07 +pendulum,3.1.0,1,34.26 +pep8-naming,0.14.1,0,100.00 +peppercorn,0.6,0,100.00 +pexpect,4.9.0,1,28.79 +phonenumbers,9.0.4,1,49.17 +pickleshare,0.7.5,0,100.00 +pika,1.3.2,0,88.46 +pillow,11.2.1,0,99.08 +Pint,0.24.4,1,40.46 +pip,25.1,1,68.27 +pip-tools,7.4.1,1,41.20 +pkginfo,1.12.1.2,0,100.00 +platformdirs,4.3.7,0,100.00 +plotly,6.0.1,1,0.00 +pluggy,1.5.0,0,99.08 +ply,3.11,1,43.18 +polars,1.28.1,2,0.00 +polyleven,0.9.0,0,100.00 +pre-commit,4.2.0,0,99.68 +preshed,3.0.9,2,0.00 +prettytable,3.16.0,0,100.00 +progress,1.6,1,0.00 +progressbar2,4.5.0,0,100.00 +prometheus-client,0.21.1,0,100.00 +prompt-toolkit,3.0.51,1,0.00 +prophet,1.1.6,1,0.00 +protobuf,6.30.2,2,0.00 +psutil,7.0.0,1,0.00 +psycopg2,2.9.10,0,97.99 +psycopg2-binary,2.9.10,0,98.13 +ptyprocess,0.7.0,1,14.29 +pure-eval,0.2.3,0,97.87 +py,1.11.0,2,0.00 +py-spy,0.4.0,1,25.00 +py4j,0.10.9.9,2,0.00 +pyaml,25.1.0,0,100.00 +pyarrow,20.0.0,0,97.58 +pyasn1,0.6.1,0,97.88 +pyasn1-modules,0.4.2,0,100.00 +PyAudio,0.2.14,2,0.00 +pyautogen,0.9,2,0.00 +PyAutoGUI,0.9.54,2,0.00 +pybind11,2.13.6,1,0.00 +pycodestyle,2.13.0,1,0.00 +pycparser,2.22,0,98.46 +pycryptodome,3.22.0,2,0.00 +pycryptodomex,3.22.0,2,0.00 +pydantic,2.11.3,0,99.86 +pydantic-settings,2.9.1,0,98.80 +pydantic_core,2.39.0,0,100.00 +pydata-sphinx-theme,0.16.1,2,0.00 +pydicom,3.0.1,0,99.70 +pydocstyle,6.3.0,0,97.20 +pydot,3.0.4,2,0.00 +PyDriller,2.7,0,100.00 +pydub,0.25.1,2,0.00 +pyfiglet,1.0.2,0,100.00 +pyflakes,3.3.2,0,99.46 +pygame,2.6.1,2,0.00 +PyGithub,2.6.1,1,45.73 +Pygments,2.19.1,0,100.00 +PyGObject,3.52.3,2,0.00 +PyJWT,2.10.1,1,0.00 +pylint,3.3.6,1,0.00 +pymdown-extensions,10.15,2,0.00 +pymongo,4.12.0,0,99.35 +PyNaCl,1.5.0,1,54.08 +pyod,2.0.3,2,0.00 +pyodbc,5.2.0,1,0.00 +pyOpenSSL,25.0.0,1,0.00 +pypandoc,1.15,0,85.71 +pyparsing,3.2.3,0,99.69 +pyperclip,1.9.0,2,0.00 +pyproj,3.7.1,0,100.00 +pyqtgraph,0.13.7,1,0.00 +pyramid,2.0.2,0,99.96 +pyrsistent,0.20.0,1,0.00 +pysam,0.23.0,1,0.00 +pyserial,3.5,0,93.48 +PySide2,5.15.2.1,2,0.00 +PySocks,1.7.1,2,0.00 +pysolr,3.10.0,1,0.00 +pyspark,3.5.5,2,0.00 +pyspnego,0.11.2,0,91.78 +pytesseract,0.3.13,0,90.00 +pytest,8.3.5,0,98.88 +pytest-asyncio,0.26.0,2,0.00 +pytest-benchmark,5.1.0,1,0.00 +pytest-cov,6.1.1,1,0.00 +pytest-django,4.11.1,0,100.00 +pytest-flake8,1.3.0,0,100.00 +pytest-mock,3.14.0,0,97.56 +pytest-mypy,1.0.1,0,93.75 +pytest-sugar,1.0.0,0,100.00 +pytest-timeout,2.3.1,0,91.49 +pytest-xdist,3.6.1,0,98.55 +python-dateutil,2.9.0.post0,0,98.76 +python-dotenv,1.1.0,0,92.67 +python-editor,1.0.4,2,0.00 +python-jose,3.4.0,0,82.34 +python-json-logger,3.3.0,2,0.00 +python-magic,0.4.27,0,95.00 +python-multipart,0.0.20,0,92.50 +python-slugify,8.0.4,0,100.00 +pytorch-lightning,2.5.1.post0,2,0.00 +pytorch-tabnet,4.1.0,2,0.00 +pytype,2024.10.11,2,0.00 +pytz,2025.2,0,100.00 +PyYAML,6.0.2,0,100.00 +pyzmq,26.4.0,0,80.49 +qrcode,8.1,0,100.00 +QtPy,2.4.3,2,0.00 +rasterio,1.4.3,2,0.00 +ray,2.44.1,2,0.00 +rdflib,7.1.4,0,99.63 +readme-renderer,44.0,0,92.39 +redis,5.2.1,1,65.34 +regex,2024.11.6,0,99.02 +reportlab,4.4.0,0,85.21 +requests,2.32.3,0,100.00 +requests-cache,1.2.1,1,44.21 +requests-kerberos,0.15.0,0,100.00 +requests-mock,1.12.1,0,100.00 +requests-oauthlib,2.0.0,1,0.00 +requests-toolbelt,1.0.0,0,84.62 +responses,0.25.7,1,0.00 +retrying,1.3.4,0,100.00 +rfc3986,2.0.0,0,100.00 +rich,14.0.0,0,99.43 +robotframework,7.2.2,1,6.10 +ruamel.yaml,0.18.10,0,100.00 +s3fs,2025.3.2,1,7.87 +s3transfer,0.12.0,1,0.00 +sacremoses,0.1.1,2,0.00 +sanic,25.3.0,1,0.00 +schedule,1.2.2,0,100.00 +schema,0.7.7,0,100.00 +scikit-image,0.25.2,0,99.90 +scikit-learn,1.6.1,1,0.00 +scipy,1.15.3,1,0.00 +Scrapy,2.12.0,1,0.00 +seaborn,0.13.2,0,99.83 +SecretStorage,3.3.3,1,26.92 +seldon-core,1.18.2,2,0.00 +selenium,4.31.0,2,0.00 +semantic-version,2.10.0,0,100.00 +semver,3.0.4,0,100.00 +sentence-transformers,4.1.0,2,0.00 +sentencepiece,0.2.0,2,0.00 +sentry-sdk,2.27.0,1,0.00 +setproctitle,1.3.5,0,82.14 +setuptools,80.0.0,1,0.00 +setuptools-scm,8.3.1,0,99.63 +setuptools-scm-git-archive,1.4.1,2,0.00 +sh,2.2.2,1,12.57 +shap,0.47.2,2,0.00 +shapely,2.1.0,0,100.00 +simplejson,3.20.1,0,100.00 +six,1.17.0,0,100.00 +skl2onnx,1.18.0,2,0.00 +sktime,0.37.0,1,0.00 +slackclient,2.9.4,0,83.70 +slicer,0.0.8,2,0.00 +smart-open,7.1.0,1,0.00 +smmap,5.0.2,0,100.00 +smmap2,3.0.1,2,0.00 +sniffio,1.3.1,0,100.00 +snowballstemmer,2.2.0,2,0.00 +sortedcontainers,2.4.0,1,0.00 +soupsieve,2.7,0,100.00 +spacy,3.8.5,1,0.00 +spacy-legacy,3.0.12,1,0.00 +spacy-loggers,1.0.5,0,100.00 +spacy-lookups-data,1.0.5,2,0.00 +spacy-model-manager,0.1.3,0,96.15 +spacy-pkuseg,1.0.0,2,0.00 +Sphinx,8.2.3,0,96.75 +sphinx-autobuild,2024.10.3,0,85.71 +sphinx-autodoc-typehints,3.2.0,1,23.30 +sphinx-click,6.0.0,0,100.00 +sphinx-gallery,0.19.0,0,99.59 +sphinx-multiversion,0.2.4,0,100.00 +sphinx-rtd-theme,3.0.2,0,100.00 +sphinxcontrib-bibtex,2.6.3,2,0.00 +SQLAlchemy,2.0.40,1,0.00 +SQLAlchemy-Utils,0.41.2,0,99.93 +sqlparse,0.5.3,0,99.78 +srsly,2.5.1,2,0.00 +stack-data,0.6.3,1,57.14 +starlette,0.46.2,1,52.70 +statsmodels,0.14.4,1,0.00 +stevedore,5.4.1,1,0.00 +streamlit,1.44.1,1,0.00 +structlog,25.3.0,0,96.60 +sympy,1.14.0,1,0.00 +tables,3.10.2,2,0.00 +tabulate,0.9.0,0,99.33 +tenacity,9.1.2,0,92.74 +tensorboard,2.19.0,2,0.00 +tensorboard-data-server,0.7.2,2,0.00 +tensorboard-plugin-wit,1.8.1,2,0.00 +tensorboardX,2.6.2.2,2,0.00 +tensorflow,2.19.0,2,0.00 +tensorflow-estimator,2.15.0,2,0.00 +tensorflow-gpu,2.12.0,2,0.00 +tensorflow-io-gcs-filesystem,0.37.1,2,0.00 +tensorflow-probability,0.25.0,2,0.00 +termcolor,3.0.1,0,83.78 +terminaltables,3.1.10,0,90.76 +testbook,0.4.2,0,100.00 +thinc,9.1.1,1,52.87 +threadloop,1.0.2,1,64.29 +threadpoolctl,3.6.0,0,100.00 +thrift,0.21.0,0,80.00 +tifffile,2025.3.30,2,0.00 +tiktoken,0.9.0,2,0.00 +tinydb,4.8.2,0,100.00 +tldextract,5.3.0,0,100.00 +tokenizers,0.21.1,0,96.43 +toml,0.10.2,0,91.30 +tomli,2.2.1,0,100.00 +tomlkit,0.13.2,0,99.88 +toolz,1.0.0,0,98.53 +torch,2.7.0,2,0.00 +torchvision,0.22.0,1,0.00 +tornado,6.4.2,0,97.53 +tox,4.25.0,2,0.00 +tqdm,4.67.1,1,3.55 +traitlets,5.14.3,0,99.47 +transformers,4.51.3,2,0.00 +trio,0.30.0,1,0.23 +twine,6.1.0,0,98.67 +Twisted,24.11.0,1,0.00 +typed-ast,1.5.5,1,0.00 +typeguard,4.4.2,0,81.65 +typer,0.15.2,1,0.00 +types-pytz,2025.2.0.20250326,1,0.00 +types-PyYAML,6.0.12.20250402,1,0.00 +types-requests,2.32.0.20250328,1,0.00 +types-setuptools,79.0.0.20250422,2,0.00 +typing-extensions,4.13.2,0,87.23 +tzlocal,5.3.1,1,4.76 +ujson,5.10.0,0,96.91 +umap-learn,0.5.7,1,0.00 +Unidecode,1.4.0,1,0.00 +urllib3,2.4.0,1,64.40 +uvicorn,0.34.2,1,11.52 +uvloop,0.21.0,1,0.00 +validators,0.34.0,0,100.00 +versioneer,0.29,0,83.94 +virtualenv,20.30.0,0,95.76 +wagtail,6.4.1,1,0.00 +waitress,3.0.2,1,0.00 +wandb,0.19.10,2,0.00 +wasabi,1.1.3,0,100.00 +watchdog,6.0.0,0,88.95 +watchfiles,1.0.5,2,0.00 +wcwidth,0.2.13,0,100.00 +webdriver-manager,4.0.2,1,52.94 +webencodings,0.5.1,0,87.50 +WebOb,1.8.9,0,98.41 +websocket-client,1.8.0,2,0.00 +websockets,15.0.1,1,0.00 +Werkzeug,3.1.3,0,99.26 +wget,3.2,0,100.00 +wheel,0.45.1,0,85.29 +wrapt,1.17.2,0,98.20 +WTForms,3.2.1,0,97.74 +xarray,2025.3.1,1,0.00 +xgboost,3.0.0,1,0.00 +xlrd,2.0.1,0,100.00 +xlwt,1.3.0,0,100.00 +xmltodict,0.14.2,0,100.00 +xxhash,3.5.0,0,100.00 +yamale,6.0.0,0,100.00 +yapf,0.43.0,2,0.00 +yarl,1.20.0,1,0.00 +youtube_dl,2021.12.17,0,86.49 +zarr,3.0.7,2,0.00 +zeep,4.3.1,0,97.96 +zipp,3.21.0,0,99.06 +zope.interface,7.2,0,96.63 diff --git a/docs/user/Embedding-Build-Tools.md b/docs/user/Embedding-Build-Tools.md index 7d6481eb0e..30e6f5c01a 100644 --- a/docs/user/Embedding-Build-Tools.md +++ b/docs/user/Embedding-Build-Tools.md @@ -1,169 +1,203 @@ # Embedding Build Tools -The GraalPy **Maven** and **Gradle** plugins provide functionality to manage Python related resources -required for embedding Python code in Java-based applications: -- *Python application files* provided by the user, for example, Python sources which are part of the project. -- *Third-party Python packages* installed by the plugin during the build according to the plugin configuration. +> **Note**: The GraalPy build tools are being developed in the [GraalPy Extensions repository](https://github.com/oracle/graalpy-extensions) on GitHub. -Apart from physically managing and deploying those files, it is also necessary to make them available in Python at runtime by configuring the **GraalPy Context** in your Java code accordingly. -The [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) API provides factory methods to create a Context preconfigured for accessing Python, embedding relevant resources with a **Virtual Filesystem** or from a dedicated **external directory**. +This guide covers advanced configuration and deployment options for the GraalPy Maven and Gradle plugins. For quick start tutorials and basic setup, see [Embedding Python in Java](Embedding-Getting-Started.md). + +The GraalPy **Maven** and **Gradle** plugins simplify embedding Python in Java applications by automatically managing Python resources during your build process: + +- **Your Python code**: Application files, modules, and scripts that are part of your project +- **Third-party packages**: Python libraries (like NumPy, requests) automatically installed in the build according to your plugin configuration. + +These plugins handle the complexity of packaging Python code with your Java application, ensuring all dependencies are available at runtime but you need to configure your Java application to access them at runtime. +The [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html) API provides factory methods that create a preconfigured GraalPy Context. + +> The preconfigured GraalPy Context is a GraalVM Context that has been automatically set up with the right settings to access your Python resources without you having to manually configure all the details. ## Deployment -There are two modes how to deploy the resources: as Java resources using the Virtual Filesystem to access them in Python, or as an external directory. +You can choose between two deployment approaches: + +- **Virtual Filesystem**: Resources are embedded within your JAR or executable +- **External Directory**: Resources are stored in a separate directory ### Virtual Filesystem -The Python related resources are embedded in the application file, either in JAR or Native Image generated -executable, as standard Java resources. -The GraalPy Virtual Filesystem internally accesses the resource files as standard Java resources and makes them available to Python code running in GraalPy. -This is transparent to the Python code, which can use standard Python IO to access those files. +With the Virtual Filesystem approach, your Python resources are embedded directly inside your JAR file or Native Image executable as standard Java resources. +This creates a self-contained application with everything bundled together. -Java resource files in a Maven or Gradle project are typically located in dedicated resources directories, such as `src/main/resources`. -Moreover, there can be multiple resources directories and Maven or Gradle usually merges them. +This approach involves the following steps: -User can choose relative Java resources path that will be made accessible in Python through the virtual filesystem, -by default it is `org.graalvm.python.vfs`. All resources subdirectories with this path are merged during build and mapped to a configurable Virtual Filesystem mount point at the Python side, by default `/graalpy_vfs`. -For example, a Python file with the real filesystem path `${project_resources_directory}/org.graalvm.python.vfs/src/foo/bar.py` will be accessible as `/graalpy_vfs/src/foo/bar.py` in Python. +- Python files are packaged as Java resources in dedicated resource directories (like `src/main/resources`) +- Multiple resource directories are merged during the build process by Maven or Gradle +- You can configure the Java resource path (default: `org.graalvm.python.vfs`) that gets mapped to a Virtual Filesystem mount point in Python (default: `/graalpy_vfs`) +- GraalPy's Virtual Filesystem transparently maps these resources to Python file paths +- Your Python code can use normal file operations (`open()`, `import`, etc.) without knowing the files are embedded -Use the following [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) -factory methods to create GraalPy Context preconfigured for the use of the Virtual Filesystem: -* `GraalPyResources.createContext()` -* `GraalPyResources.contextBuilder()` -* `GraalPyResources.contextBuilder(VirtualFileSystem)` +For example, a file at `src/main/resources/org.graalvm.python.vfs/src/mymodule.py` becomes accessible to Python as `/graalpy_vfs/src/mymodule.py`. + +You can customize the resource path (default: `org.graalvm.python.vfs`) and mount point (default: `/graalpy_vfs`) to avoid conflicts with other libraries. + +To use the Virtual Filesystem in your Java application, use the factory methods in the [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html) API: + +- `GraalPyResources.createContext()` - Creates a ready-to-use context with default Virtual Filesystem configuration +- `GraalPyResources.contextBuilder()` - Returns a context builder for additional customization before creating the context +- `GraalPyResources.contextBuilder(VirtualFileSystem)` - Returns a context builder with a custom Virtual Filesystem configuration #### Java Resource Path -Particularly when developing reusable libraries, it is recommended to use custom unique Java resources path for your -virtual filesystem to avoid conflicts with other libraries on the classpath or module path that may also use the -Virtual Filesystem. The recommended path is: + +When building reusable libraries, use a unique Java resource path to prevent conflicts with other Virtual Filesystem users. +This ensures your library's Python resources don't interfere with other libraries on the classpath. + +The recommended path is: ```bash GRAALPY-VFS/${project.groupId}/${project.artifactId} ``` -The Java resources path must be configured in the Maven and Gradle plugins and must be also set to the same value -at runtime using the `VirtualFileSystem$Builder#resourceDirectory` API. +This path must be configured identically in both your build plugin and runtime code using the `VirtualFileSystem$Builder#resourceDirectory` API. -*Note regarding Java module system: resources in named modules are subject to the encapsulation rules specified by -[Module.getResourceAsStream](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Module.html#getResourceAsStream(java.lang.String)). -This is also the case of the default virtual filesystem location. -When a resources directory is not a valid Java package name, such as the recommended "GRAALPY-VFS", the resources are not subject to the encapsulation rules and do not require additional module system configuration.* +> **Java Module System compatibility:** The "GRAALPY-VFS" prefix bypasses module encapsulation rules since it's not a valid Java package name, eliminating the need for additional module system configuration that would otherwise be required for accessing resources in named modules. #### Extracting files from Virtual Filesystem -Normally, Virtual Filesystem resources are loaded like java resources, but there are cases when files need to be accessed -outside the Truffle sandbox, e.g. Python C extension files which need to be accessed by the operating system loader. -By default, files which are of type `.so`, `.dylib`, `.pyd`, `.dll`, or `.ttf`, are automatically extracted to a temporary directory -in the real filesystem when accessed for the first time and the Virtual Filesystem then delegates to those real files. +Some files need to exist on the real filesystem rather than staying embedded as Java resources. -The default extract rule can be enhanced using the `VirtualFileSystem$Builder#extractFilter` API. +This is required for Python C extensions (`.so`, `.dylib`, `.pyd`, `.dll`) and other files that are opened directly by native libraries outside Python's file APIs. +GraalPy automatically extracts common native library and font file types such as `.so`, `.dylib`, `.pyd`, `.dll`, and `.ttf` when first accessed, then delegates to the real files for subsequent operations. -Alternatively, it is possible to extract all Python resources into a user-defined directory before creating a GraalPy -context, and then configure the context to use that directory. Please refer to the following [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) -methods for more details: -* `GraalPyResources.extractVirtualFileSystemResources(VirtualFileSystem vfs, Path externalResourcesDirectory)` -* `GraalPyResourcescontextBuilder(Path externalResourcesDirectory)` +If a package reports that an embedded file under `/graalpy_vfs` does not exist, check whether a native library is opening that file directly. +For example, packages using ONNX Runtime may need model files such as `.onnx` to be extracted as real files. + +Use the `VirtualFileSystem$Builder#extractFilter` API to customize which files are extracted automatically. +For full control, extract all resources to a user-defined directory before creating your GraalPy context: + +- `GraalPyResources.extractVirtualFileSystemResources(VirtualFileSystem vfs, Path externalResourcesDirectory)` - Extract resources to a specified directory +- `GraalPyResources.contextBuilder(Path externalResourcesDirectory)` - Create a context builder using the extracted resources directory + +For more information, see [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html). ### External Directory -As an alternative to Java resources with the Virtual Filesystem, it is also possible to configure the Maven or Gradle plugin to manage the contents of an external directory, which will **not be embedded** as a Java resource into the resulting application. -A user is then responsible for the deployment of such directory. -Python code will access the files directly from the real filesystem. +With the External Directory approach, your Python resources are stored in a separate directory on the filesystem rather than being embedded as Java resources. +This creates a deployment where Python files exist as regular files that you must distribute alongside your application. + +This approach involves the following steps: + +- Python files remain as regular filesystem files (not embedded as Java resources) +- You are responsible for deploying and managing the external directory +- Python code accesses files directly from the real filesystem +- Smaller JAR/executable size since Python resources aren't embedded -Use the following [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) factory methods to create GraalPy Context preconfigured for the use of an external directory: -* `GraalPyResources.createContextBuilder(Path)` +To use an external directory, create your GraalPy context with: +- `GraalPyResources.createContextBuilder(Path)` - Creates a context builder pointing to your external directory path -## Conventions +## Directory Structure -The factory methods in [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) rely on the following conventions, where the `${root}` is either an external directory, or a Virtual System mount point on the Python side and Java resources directories, such as `${project_resources_directory}/org.graalvm.python.vfs`, on the real filesystem: -- `${root}/src`: used for Python application files. This directory will be configured as the default search path for Python module files (equivalent to `PYTHONPATH` environment variable). -- `${root}/venv`: used for the Python virtual environment holding installed third-party Python packages. -The Context will be configured as if it is executed from this virtual environment. Notably packages installed in this -virtual environment will be automatically available for importing. +The [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html) factory methods rely on this directory structure, which includes a standard [Python virtual environment](https://docs.python.org/3.11/tutorial/venv.html) in the `venv` subdirectory: -The Maven or Gradle plugin will fully manage the contents of the `venv` subdirectory. -Any manual change will be overridden by the plugin during the build. -- `${root}/venv`: the plugin creates a virtual environment and installs required packages according to the plugin configuration in _pom.xml_ or _build.gradle_. +| Directory | Purpose | Management | Python Path | +| --------------- | ---------------------------- | ------------------ |------------ | +| `${root}/src/` | Your Python application code | **You manage** | Default search path (equivalent to `PYTHONPATH`) | +| `${root}/venv/` | Third-party Python packages | **Plugin manages** | Context configured as if executed from this virtual environment | -The _src_ subdirectory is left to be manually populated by the user with custom Python scripts or modules. +The `${root}` placeholder refers to different locations depending on your deployment approach: -To manage third-party Python packages, a [Python virtual environment](https://docs.python.org/3.11/tutorial/venv.html) is used behind the scenes. -Whether deployed in a virtual filesystem or an external directory, its contents are managed by the plugin based on the Python packages -specified in the plugin configuration. +- **Virtual Filesystem**: `/graalpy_vfs` (Python) / `${project_resources_directory}/org.graalvm.python.vfs` (Java) +- **External Directory**: Filesystem path like `python-resources/` -## Python Dependency Management for Reproducible Builds +The GraalPy Context is automatically configured to run within this virtual environment, making all installed packages available for import. -In Python ecosystem, it is common that packages specify their dependencies as ranges rather than a fixed version. -For example, package A depends on package B of any version higher or equal to 2.0.0 (denoted as `B>=2.0.0`). -Installation of package A today may pull package `B==2.0.0`. Tomorrow package B releases new version `2.0.1` -and a clean build of a project depending on A will pull new version of B, which may not be compatible -with GraalPy or may introduce (unintentional) breaking changes. +> **Important**: Plugin completely manages `venv/` - any manual changes will be overridden during builds. + +## Dependency Management + +Python packages typically specify dependencies as version ranges (e.g., `B>=2.0.0`) rather than fixed versions. +This means today's build might install `B==2.0.0`, but tomorrow's clean build could pull the newly released `B==2.0.1`, potentially introducing breaking changes or GraalPy incompatibilities. ### Locking Dependencies -We **highly recommend locking** all Python dependencies whenever there is a change in the list of required packages -for a project. Locking the dependencies means explicitly invoking a Maven goal or Gradle task that generates file -`graalpy.lock` that captures versions of all Python package dependencies: those specified explicitly in -`pom.xml` or `build.gradle` and all their transitive dependencies. +**We highly recommend locking all Python dependencies** when packages change. +Run a Maven goal or Gradle task to generate _graalpy.lock_, which captures exact versions of all dependencies (those specified explicitly in the _pom.xml_ or _build.gradle_ files and all their transitive dependencies). + +Commit the _graalpy.lock_ file to version control (e.g., git). +Once this file exists, Maven or Gradle builds will install the exact same package versions captured in the _graalpy.lock_ file. -The `graalpy.lock` file should be commited to version control system (e.g., git). Once the `graalpy.lock` file exists, -the package installation during Maven or Gradle build installs the exact same versions as captured in `graalpy.lock`. +If you modify dependencies in _pom.xml_ or _build.gradle_ and they no longer match what's in _graalpy.lock_, the build will fail and the user will be asked to explicitly regenerate the _graalpy.lock_ file. -When the set of explicit dependencies in `pom.xml` or `build.gradle` changes and does not match what is in -`graalpy.lock` anymore, the build will fail and the user will be asked to explicitly regenerate the `graalpy.lock` file. +We recommend specifying dependencies without version numbers in the _pom.xml_ or _build.gradle_ file. +GraalPy automatically installs compatible versions for well-known packages. -Note that unless specific version of a package is desired, we recommend to specify explicit dependencies in -`pom.xml` or `build.gradle` without version quantifier. For some well known packages, GraalPy automatically -installs the version that is known to be compatible with GraalPy. However, once installed, the versions should be -locked to ensure reproducible builds. +Once installed, lock these versions to ensure reproducible builds. -For information on the specific Maven or Gradle lock packages actions, please refer to the -Locking Python Packages subsections below. +See the "Locking Python Packages" sections below for specific Maven and Gradle commands. + +For information on the specific Maven or Gradle lock packages actions, see the [Locking Python Packages](#locking-python-packages) section. ## GraalPy Maven Plugin +The GraalPy Maven Plugin automates Python resource management in Maven-based Java projects. +It downloads Python packages, creates virtual environments, and configures deployment for both Virtual Filesystem (embedded) and External Directory approaches. + ### Maven Plugin Configuration -Add the plugin configuration in the `configuration` block of `graalpy-maven-plugin` in the _pom.xml_ file: +Configure the plugin in your _pom.xml_ file with these elements: + +| Element | Description | +| ------------------- | ------------ | +| `packages` | Python dependencies using pip syntax (e.g., `requests>=2.25.0`) - optional | +| `requirementsFile` | Path to pip-compatible _requirements.txt_ file - optional, mutually exclusive with `packages` | +| `resourceDirectory` | Custom path for [Virtual Filesystem](#virtual-filesystem) deployment (must match Java runtime configuration) | +| `externalDirectory` | Path for [External Directory](#external-directory) deployment (mutually exclusive with `resourceDirectory`) | + +Add the plugin configuration to your _pom.xml_ file: + ```xml org.graalvm.python graalpy-maven-plugin - ... - ... + + + termcolor==2.2 + + + + + GRAALPY-VFS/${project.groupId}/${project.artifactId} + + + ${basedir}/python-resources - ... ``` -- The **packages** element declares a list of third-party Python packages to be downloaded and installed by the plugin. -The Python packages and their versions are specified as if used with `pip`: - ```xml - - - termcolor==2.2 - ... - - ... - - ``` - -- The **resourceDirectory** element can specify the relative [Java resource path](#java-resource-path). - Remember to use `VirtualFileSystem$Builder#resourceDirectory` when configuring the `VirtualFileSystem` in Java. - ```xml - GRAALPY-VFS/${project.groupId}/${project.artifactId} - ``` - -- If the **externalDirectory** element is specified, then the given directory is used as an [external directory](#external-directory) and no Java resources are embedded. -Remember to use the appropriate `GraalPyResources` API to create the Context. This element and **resourceDirectory** are mutually exclusive. - ```xml - - ${basedir}/python-resources - ... - - ``` - -- If you want to remove packages that are only needed during venv creation but not at runtime, such as setuptools or pip, you can use e.g. the `maven-jar-plugin`: - ```xml + +#### Using `requirements.txt` + +The `requirementsFile` element declares a path to a pip-compatible _requirements.txt_ file. +When configured, the plugin forwards this file directly to pip using `pip install -r`, +allowing full use of pip's native dependency format. + +```xml + + requirements.txt + ... + +``` + +> **Important:** You must configure either `packages` or `requirementsFile`, but not both. +> +> When `requirementsFile` is used: +> - the GraalPy lock file is **not created and not used** +> - the `lock-packages` goal is **disabled** +> - dependency locking must be handled externally by pip (for example using `pip freeze`) +> +> Mixing `packages` and `requirementsFile` in the same configuration is not supported. + +#### Excluding Build-Only Packages + +You can remove build-only packages from final JAR using `maven-jar-plugin`: + +```xml org.apache.maven.plugins maven-jar-plugin @@ -175,99 +209,97 @@ Remember to use the appropriate `GraalPyResources` API to create the Context. Th - ``` +``` ### Locking Python Packages -To lock the dependency tree of the specified Python packages, execute the GraalPy plugin goal `org.graalvm.python:graalpy-maven-plugin:lock-packages`. + +Generate a lock file to ensure reproducible builds: + ```bash $ mvn org.graalvm.python:graalpy-maven-plugin:lock-packages ``` -*Note that the action will override the existing lock file.* - -For a high level description of this feature, please refer to the -[Python Dependency Management for Reproducible Builds](#pythop-dependency-management-for-reproducible-builds) section -in this document. - -* The **graalPyLockFile** element can change the default path to the GraalPy lock file. Default value is `${basedir}/graalpy.lock`. - The **graalPyLockFile** element by itself will not trigger the locking. The locking must be done by explicitly executing the - `org.graalvm.python:graalpy-maven-plugin:lock-packages` goal. - ```xml - - ${basedir}/graalpy.lock - ... - - ``` + +> **Note:** This action overwrites any existing _graalpy.lock_ file. + +To customize the lock file path, configure _graalPyLockFile_ : + +```xml + + ${basedir}/graalpy.lock + +``` + +> **Note:** This only changes the path (defaults to _${basedir}/graalpy.lock_).To generate the lock file, run the `lock-packages` goal. + +For more information of this feature, please see the +[Python Dependency Management for Reproducible Builds](#python-dependency-management-for-reproducible-builds) section. ## GraalPy Gradle Plugin +The GraalPy Gradle Plugin automates Python resource management in Gradle-based Java projects. +It downloads Python packages, creates virtual environments, and configures deployment for both Virtual Filesystem (embedded) and External Directory approaches. + ### Gradle Plugin Configuration -The plugin must be added to the plugins section in the _build.gradle_ file. -The **version** property defines which version of GraalPy to use. + +Configure the plugin in your _build.gradle_ file with these elements: + +| Element | Description | +| ------------------- | ------------ | +| `packages` | Python dependencies using pip syntax (e.g., `requests>=2.25.0`) | +| `resourceDirectory` | Custom path for [Virtual Filesystem](#virtual-filesystem) deployment (must match Java runtime configuration) | +| `externalDirectory` | Path for [External Directory](#external-directory) deployment (mutually exclusive with `resourceDirectory`) | + +Add the plugin configuration to your _build.gradle_ file: + ```groovy plugins { - // other plugins ... - id 'org.graalvm.python' version '24.2.0' + id 'org.graalvm.python' version '25.0.3' +} + +graalPy { + // Python packages (pip-style syntax) + packages = ["termcolor==2.2"] + + // Choose ONE deployment approach: + // Virtual Filesystem (embedded) + resourceDirectory = "GRAALPY-VFS/my.group.id/artifact.id" + + // OR External Directory (separate files) + externalDirectory = file("$rootDir/python-resources") } ``` The plugin automatically injects these dependencies of the same version as the plugin version: - - `org.graalvm.python:python` - - `org.graalvm.python:python-embedding` -The plugin can be configured in the `graalPy` block: +- `org.graalvm.python:python` +- `org.graalvm.python:python-embedding` -- The **packages** element declares a list of third-party Python packages to be downloaded and installed by the plugin. - The Python packages and their versions are specified as if used with `pip`. - ```bash - graalPy { - packages = ["termcolor==2.2"] - ... - } - ``` - -- The **resourceDirectory** element can specify the relative [Java resource path](#java-resource-path). - Remember to use `VirtualFileSystem$Builder#resourceDirectory` when configuring the `VirtualFileSystem` in Java. - ```bash - resourceDirectory = "GRAALPY-VFS/my.group.id/artifact.id" - ``` - -- If the **externalDirectory** element is specified, then the given directory is used as an [external directory](#external-directory) and no Java resources are embedded. - Remember to use the appropriate `GraalPyResources` API to create the Context. - ```bash - graalPy { - externalDirectory = file("$rootDir/python-resources") - ... - } - ``` -- Boolean flag **community** switches the automatically injected -dependency `org.graalvm.python:python` to the community build: `org.graalvm.python:python-community`. - ```bash - graalPy { - community = true - ... - } - ``` ### Locking Python Packages -To lock the dependency tree of the specified Python packages, execute the GraalPy plugin task `graalPyLockPackages`. + +Generate a lock file to ensure reproducible builds: + ```bash gradle graalPyLockPackages ``` -*Note that the action will override the existing lock file.* -For a high level description of this feature, please refer to the -[Python Dependency Management for Reproducible Builds](#pythop-dependency-management-for-reproducible-builds) section -in this document. +> **Note:** This overwrites any existing _graalpy.lock_ file. + +To customize the lock file path, configure _graalPyLockFile_: -* The **graalPyLockFile** element can change the default path to the GraalPy lock file. Default value is `${basedir}/graalpy.lock`. - The **graalPyLockFile** element by itself will not trigger the locking. The locking must be done by explicitly executing the - `graalPyLockPackages` task. - ``` +```groovy graalPy { graalPyLockFile = file("$rootDir/graalpy.lock") ... } +``` + +> **Note:** This only changes the path (defaults to _$rootDir/graalpy.lock_). To generate the lock file, run the `graalPyLockPackages` task. + +For more information of this feature, please see the +[Python Dependency Management for Reproducible Builds](#python-dependency-management-for-reproducible-builds) section. -## Related Documentation +### Related Documentation -* [Embedding Graal languages in Java](https://www.graalvm.org/reference-manual/embed-languages/) -* [Permissions for Python Embeddings](Embedding-Permissions.md) +- [Embedding Graal languages in Java](https://www.graalvm.org/reference-manual/embed-languages/) +- [Permissions for Python Embeddings](Embedding-Permissions.md) +- [GraalPy extensions on GitHub](https://github.com/oracle/graalpy-extensions) diff --git a/docs/user/Embedding-Getting-Started.md b/docs/user/Embedding-Getting-Started.md new file mode 100644 index 0000000000..7ce3c82c37 --- /dev/null +++ b/docs/user/Embedding-Getting-Started.md @@ -0,0 +1,220 @@ +# Embedding Python in Java + +This guide shows you how to embed Python code directly in Java applications using GraalPy. +You can use GraalPy with any JDK (GraalVM JDK, Oracle JDK, or OpenJDK). + +GraalPy provides dedicated Maven and Gradle plugins that handle all the complexity for you. +If you are using other build systems (Ant, Make, CMake), manual configuration is required. + +## Maven Quick Start + +The fastest way to get started is with GraalPy's Maven archetype, which generates a complete starter project for you. + +1. Generate a new project using the GraalPy Maven archetype: + + ```bash + mvn archetype:generate \ + -DarchetypeGroupId=org.graalvm.python \ + -DarchetypeArtifactId=graalpy-archetype-polyglot-app \ + -DarchetypeVersion=25.0.3 + ``` + + This generates the following project structure: + + ```bash + └── polyglot-app + ├── pom.xml + ├── src + │ └── main + │ ├── java + │ │ └── com + │ │ └── example + │ │ └── Main.java + │ └── resources + └── target/ + ``` + +2. Build a native executable using the [GraalVM `native-image` tool](https://www.graalvm.org/latest/reference-manual/native-image/) that was added for you automatically: + + ```bash + mvn -Pnative package + ``` + +3. Once completed, run the executable: + + ```bash + ./target/polyglot_app + ``` + + You should see "hello java" printed to the console. + +The generated project includes everything you need: the [GraalVM Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) for Python execution, Python virtual environment management, and examples showing how to integrate Python packages. +The generated _pom.xml_ and Java code are well-documented with explanations of all features. + +For advanced plugin configuration, deployment options, and dependency management, see the [Embedding Build Tools](Embedding-Build-Tools.md) guide. + +### Cross-Platform Distribution + +For creating cross-platform JARs with native Python packages, see the [Virtual Filesystem deployment section](Embedding-Build-Tools.md#virtual-filesystem) in the Build Tools guide. + +## Gradle Quick Start + +If you prefer Gradle, here is how to set up a new project with GraalPy embedding: + +1. Create a new Java application with Gradle: + + ```bash + gradle init --type java-application \ + --project-name interop \ + --package interop \ + --no-split-project + ``` + + This generates the following project structure: + + ```bash + └── app + ├── build.gradle + └── src + └── main + ├── java + │ └── interop + │ └── App.java + └── resources + ``` + +2. Add GraalPy dependencies to your _app/build.gradle_ file. + - Include the GraalPy support and the [GraalVM Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) in the `dependencies` section: + + ```gradle + implementation("org.graalvm.polyglot:polyglot:25.0.3") + implementation("org.graalvm.python:python-embedding:25.0.3") + ``` + +3. Replace the _App.java_ content with this simple Python embedding example: + + ```java + package interop; + + import org.graalvm.polyglot.*; + import org.graalvm.python.embedding.GraalPyResources; + + class App { + public static void main(String[] args) { + try (var context = GraalPyResources.createContext()) { + System.out.println(context.eval("python", "'Hello Python!'").asString()); + } + } + } + ``` + +4. Run the application with Gradle: + + ```bash + ./gradlew run + ``` + + The application prints "Hello Python!" to the console. + + > **Note**: GraalPy's performance depends on the JDK you are using. For optimal performance, see the [Runtime Optimization Support](https://www.graalvm.org/latest/reference-manual/embed-languages/#runtime-optimization-support) guide. + +### Adding Python Dependencies + +To use third-party Python packages like NumPy or Requests in your embedded application: + +1. Add the GraalPy Gradle plugin and configure dependencies in _app/build.gradle_: + + ```gradle + plugins { + id "java" + id "application" + id "org.graalvm.python" version "25.0.3" + } + + graalPy { + packages = ["termcolor==2.2"] + } + ``` + +2. Update your Java code to use the Python package: + + ```java + package interop; + + import org.graalvm.polyglot.*; + import org.graalvm.python.embedding.GraalPyResources; + + class App { + public static void main(String[] args) { + try (Context context = GraalPyResources.contextBuilder().build()) { + String src = """ + from termcolor import colored + colored_text = colored("hello java", "red", attrs=["reverse", "blink"]) + print(colored_text) + """; + context.eval("python", src); + } + } + } + ``` + +For complete plugin configuration options, deployment strategies, and dependency management, see [Embedding Build Tools](Embedding-Build-Tools.md). + +## Other Build Systems (Ant, CMake, Makefile) + +If you are using build systems like Ant, Makefiles, or CMake that do not directly support Maven dependencies, you can still use GraalPy. +Projects like [Apache Ivy™](https://ant.apache.org/ivy/history/master/tutorial/start.html) can resolve Maven dependencies for these systems, you might prefer a simpler approach. +GraalPy provides a tool to download the required JAR files directly. + +### Manual Setup + +1. Set up your project structure with a directory for dependencies: + + ```bash + ├── lib/ # JAR dependencies + │ └── *.jar + └── src/ # Your Java source files + └── *.java + ``` + +2. Download GraalPy dependencies using the bundled tool: + + First, [install GraalPy](Standalone-Getting-Started.md#installation) and ensure `graalpy` is in your PATH. + + Then run the appropriate command for your system: + + **On Linux/macOS:** + + ```bash + export GRAALPY_HOME=$(graalpy -c 'print(__graalpython__.home)') + export GRAALPY_VERSION=$(graalpy -c 'import __graalpython__; print(__graalpython__.version)') + "${GRAALPY_HOME}/libexec/graalpy-polyglot-get" -a python -o lib -v "${GRAALPY_VERSION}" + ``` + + **On Windows (PowerShell):** + + ```powershell + $GRAALPY_HOME = graalpy -c "print(__graalpython__.home)" + $GRAALPY_VERSION = graalpy -c "import __graalpython__; print(__graalpython__.version)" + & "$GRAALPY_HOME/libexec/graalpy-polyglot-get" -a python -o lib -v "$GRAALPY_VERSION" + ``` + + This downloads all required GraalPy JARs into your _lib_ directory. + +3. Write your embedding code: + + ```java + import org.graalvm.polyglot.*; + + public class Hello { + public static void main(String[] args) { + try (var context = Context.newBuilder() + .option("engine.WarnInterpreterOnly", "false") + .build()) { + System.out.println(context.eval("python", "'Hello Python!'").asString()); + } + } + } + ``` + + Make sure your build system includes all JARs from the _lib_ directory in the classpath. diff --git a/docs/user/Embedding-Native-Extensions.md b/docs/user/Embedding-Native-Extensions.md new file mode 100644 index 0000000000..c413e66c6f --- /dev/null +++ b/docs/user/Embedding-Native-Extensions.md @@ -0,0 +1,52 @@ +# Embedding Limitations for Native Extensions + +Python native extensions run by default as native binaries, with full access to the underlying system. +This has a few implications: + +1. Native code is entirely unrestricted and can circumvent any security protections Truffle or the JVM may provide. +2. Native data structures are not subject to the Java GC and the combination of them with Java data structures may lead to increased memory pressure or memory leaks. +3. Native libraries generally cannot be loaded multiple times into the same process, and they may contain global state that cannot be safely reset. + +## Full Native Access + +The Context API allows you to set options such as `allowIO`, `allowHostAccess`, `allowThreads`, and more on created contexts. +To use Python native extensions on GraalPy, the `allowNativeAccess` option must be set to `true`, but this opens the door to full native access. +This means that while Python code may be denied access to the host file system, thread or subprocess creation, and more, the native extension is under no such restriction. + +## Java Virtual Threads + +Python native extensions are not compatible with Java virtual threads. +Native extensions commonly use native thread-local state, including CPython and extension-runtime state that cannot track Java virtual-thread scheduling. +If an embedded application may load or call native extensions, run that Python code on platform threads. +For example, server applications that use virtual threads for request handling should dispatch GraalPy calls that may use native extensions to a platform-thread executor. + +## Memory Management + +Python C extensions, like the CPython reference implementation, use reference counting for memory management. +This is fundamentally incompatible with JVM GCs. + +Java objects may end up being referenced from native data structures that the JVM cannot trace, so to avoid crashing, GraalPy keeps such Java objects strongly referenced. +To avoid memory leaks, GraalPy implements a cycle detector that regularly traces references between Java objects and native objects that have crossed between the two worlds and cleans up strong references that are no longer needed. + +On the other side, reference-counted native extension objects may end up being referenced from Java objects, and in this case GraalPy bumps their reference count to make them unreclaimable. +Any such references to native extension objects are registered with a `java.lang.ref.WeakReference`, and when the JVM GC has collected the owning Java object, the reference count of the native object is reduced again. + +Both of these mechanisms together mean there is additional delay between objects becoming unreachable and their memory being reclaimed when compared to the CPython implementation. +This can manifest in increased memory usage when running C extensions. +You can tweak the context options `python.BackgroundGCTaskInterval`, `python.BackgroundGCTaskThreshold`, and `BackgroundGCTaskMinimum` to mitigate this. +They control the minimum interval between cycle detections, how much RSS memory must have increased since the last time to trigger the cycle detector, and the absolute minimum RSS under which no cycle detection should be done. +You can also manually trigger the detector with the Python `gc.collect()` call. + +## Multi-Context and Native Libraries + +Using C extensions in multiple contexts is only possible on Linux for now, and many C extensions still have issues in this mode. +You should test your applications thoroughly if you want to use this feature. +There are many possibilities for native code to sidestep the library isolation through other process-wide global state, corrupting the state and leading to incorrect results or crashing. +The implementation also relies on `venv` to work, even if you are not using external packages. + +To support creating multiple GraalPy contexts that access native modules within the same JVM or Native Image, GraalPy isolates them from each other. +The current strategy for this is to copy the libraries and modify them such that the dynamic library loader of the operating system will isolate them. +To do this, all GraalPy contexts in the same process, not just those in the same engine, must set the `python.IsolateNativeModules` option to `true`. +You should test your applications thoroughly if you want to use this feature, as there are many possibilities for native code to sidestep the library isolation through other process-wide global state. + +For more details on this, see [our implementation details](https://github.com/oracle/graalpython/blob/master/docs/contributor/IMPLEMENTATION_DETAILS.md#c-extension-copying). diff --git a/docs/user/Embedding-Permissions.md b/docs/user/Embedding-Permissions.md index aec8ea7a50..316714b44c 100644 --- a/docs/user/Embedding-Permissions.md +++ b/docs/user/Embedding-Permissions.md @@ -1,75 +1,131 @@ # Permissions for Python Embeddings -## Access Control and Security Limits for Python Scripts +When embedding GraalPy in Java applications, you need to understand how Python scripts access system resources and what security limitations apply. -Embedding GraalPy into Java works with the [GraalVM Polyglot Sandbox](https://www.graalvm.org/latest/reference-manual/embed-languages/#controlling-access-to-host-functions). +GraalPy integrates with the [GraalVM Polyglot Sandbox](https://www.graalvm.org/latest/reference-manual/embed-languages/#controlling-access-to-host-functions) to provide configurable access control for embedded Python code. ## Python's POSIX Interface -The way the operating system interface is exposed to Python scripts is GraalPy-specific. -By default all access is routed through Java interfaces, but some packages rely on details of POSIX APIs and require direct native access. +GraalPy exposes the operating system interface to Python scripts in a GraalPy-specific way. +By default, all access is routed through Java interfaces, but some packages rely on POSIX API details and require direct native access. -Graal languages (those implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)) usually implement system-related functions using the [Truffle abstraction layer](https://github.com/oracle/graal/blob/master/truffle/docs/README.md), which is OS independent and provides extension points for the users when embedding GraalPy or other Graal languages into Java applications. -See, for example, the [Truffle FileSystem service-provider](https://www.graalvm.org/truffle/javadoc/org/graalvm/polyglot/io/FileSystem.html). +Graal languages (implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)) typically implement system-related functions using the [Truffle abstraction layer](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/). +This layer is OS-independent and provides extension points when embedding GraalPy or other Graal languages into Java applications. +For example, see the [Truffle FileSystem service-provider](https://www.graalvm.org/truffle/javadoc/org/graalvm/polyglot/io/FileSystem.html). -The standard Python library also provides an OS abstraction, but exposes lower level interfaces. For example, the `os` module directly exposes some POSIX functions. +The standard Python library also provides an OS abstraction, but exposes lower level interfaces. +For example, the `os` module directly exposes some POSIX functions. On non-POSIX platforms, this interface is emulated to a degree. -GraalPy provides two alternative implementations (each referred to as a "backend") of system-related functionality offered by built-in Python modules such as `os`. -The `PosixModuleBackend` option determines which backend is used: valid values are `native` and `java`. +GraalPy provides two alternative implementations ("backends") of system-related functionality for built-in Python modules such as `os`. +The `PosixModuleBackend` option determines which backend is used: `native` or `java`. ### Native Backend -This backend directly calls the POSIX API in mostly the same way as CPython (the reference Python implementation). +The native backend directly calls the POSIX API in mostly the same way as CPython (the reference Python implementation). -This approach is the most compatible with CPython and provides bare access to the underlying OS interface without an intermediate emulation layer. +This approach is the most compatible with CPython and provides bare access to the underlying OS interface without an intermediate emulation layer. -By default, this implementation bypasses the Truffle abstraction layer, and therefore it is not sandboxed and does not support custom implementations of [Truffle FileSystem service-provider](https://www.graalvm.org/truffle/javadoc/org/graalvm/polyglot/io/FileSystem.html), and other Polyglot API providers related to system interfaces. +However, this implementation bypasses the Truffle abstraction layer by default. +This means: +- **No sandboxing** protection +- **No support** for custom [Truffle FileSystem service-provider](https://www.graalvm.org/truffle/javadoc/org/graalvm/polyglot/io/FileSystem.html) implementations +- **No support** for other Polyglot API providers related to system interfaces -The native backend is chosen by default when GraalPy is started via the `graalpy` or any other Python related launcher. +The native backend is chosen by default when GraalPy is started via the `graalpy` launcher or any other Python-related launcher. #### Limitations of the Native Backend -Known limitations are: +Known limitations: -* `os.fork` is not supported -* `_posixsubprocess.fork_exec` does not support the `preexec_fn` parameter +- `os.fork` is not supported +- `_posixsubprocess.fork_exec` does not support the `preexec_fn` parameter ### Java Backend -This backend uses the [Truffle abstraction layer](https://github.com/oracle/graal/blob/master/truffle/docs/README.md) and therefore supports custom Polyglot API providers related to system interfaces and sandboxing. -Because this abstraction is POSIX agnostic, it does not expose all the necessary functionality. Some functionality is emulated, and some functionality is unsupported. +The Java backend uses the [Truffle abstraction layer](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/), which provides: -The Java backend is the default when GraalPy is run via the `Context` API, that is, [embedded in Java applications](https://github.com/oracle/graal/blob/master/docs/reference-manual/embedding/embed-languages.md). +- **Sandboxing support** for security +- **Custom Polyglot API providers** for system interfaces +- **Cross-platform compatibility** + +Because this abstraction is POSIX-agnostic, it cannot expose all necessary functionality. +Some functionality is emulated, and some is unsupported. + +The Java backend is the default when [embedding GraalPy in Java applications](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/package-summary.html) using the `Context` API. #### Limitations of the Java Backend -GraalPy can log information about known incompatibility of functions executed at runtime, which includes the OS interface-related functions. -To turn on this logging, use the command-line option `--log.python.compatibility.level=FINE` (or other desired logging level). +To help identify compatibility issues, GraalPy can log information about known incompatibilities of functions executed at runtime. +To enable this logging, use: `--log.python.compatibility.level=FINE` Known limitations of the Java backend are: -* Its state is disconnected from the actual OS state, which applies especially to: - * *file descriptors*: Python-level file descriptors are not usable in native code. - * *current working directory*: is initialized to the current working - directory at the startup, but is then maintained separately. So, for example, `chdir` in Python - does not change the actual current working directory of the process. - * *umask*: has the same limitation as that of the current working directory, but it is always initialized - to `0022` regardless of the actual system value at startup. -* Resolution of file access/modification times depends on the JDK. - The best the Java backend can guarantee is seconds resolution. -* `os.access` and any other functionality based on `faccessat` POSIX function does not support: - * effective IDs. - * `follow_symlinks=False` unless the mode is only `F_OK`. +**State Isolation:** -## Python Native Extensions +The Java backend's state is disconnected from the actual OS state: + +- **File descriptors:** Python-level file descriptors are not usable in native code +- **Current working directory:** Initialized to the startup directory but maintained separately. For example, `os.chdir()` in Python does not change the actual process working directory +- **umask:** Same limitation as working directory, but always initialized to `0022` regardless of the actual system value + +**Other Limitations:** + +- **File timestamps:** Resolution depends on the JDK. The Java backend can only guarantee seconds resolution +- **File access checks:** `os.access()` and functionality based on the `faccessat` POSIX function do not support: + - Effective IDs + - `follow_symlinks=False` unless the mode is only `F_OK` + +## Context Security Configuration + +When embedding GraalPy using the Polyglot API, you can configure security and access permissions through the `Context.Builder` class. +These settings control what system resources and host functionality your embedded Python code can access. + +This table shows the common security methods: + +| Method | Description | Notes | +| ----------------------------------------- | -------------------------------------------------------------------------- | ------- | +| `allowAllAccess(boolean)` | Grants unrestricted access to all host functionality and system resources. | **Security Risk:** Should only be used in trusted environments or for testing. When `true`, bypasses most security restrictions. When `false` (default), access is controlled by other specific permission methods. | +| `allowHostAccess(HostAccess)` | Controls access to Java host objects and classes. | Use `HostAccess.ALL` for unrestricted access or create custom policies. Default is `HostAccess.NONE` which blocks host access. | +| `allowHostClassLookup(Predicate)` | Controls which Java classes can be looked up by name from Python. | Accepts a predicate function to filter allowed class names. More granular than `allowHostAccess` for class loading. | +| `allowPolyglotAccess(boolean)` | Controls access to other polyglot languages and their objects. | Required for interop with other languages like JavaScript. Default is `false`. | +| `allowIO(IOAccess)` | Controls file system and network access. | Use `IOAccess.ALL` for full access, `IOAccess.NONE` to block all I/O. Can create custom policies for specific paths or protocols. | +| `allowEnvironmentAccess(boolean)` | Controls access to environment variables. | Required for accessing `os.environ["PATH"]` and other environment variables. Default is `false`. | +| `allowCreateProcess(boolean)` | Controls whether Python code can create new processes. | Required for the `subprocess` module to work. Default is `false`. | +| `allowCreateThread(boolean)` | Controls whether Python code can create new threads. | Default is `false` for security. | +| `allowNativeAccess(boolean)` | Controls access to native libraries and system calls. | Required for Python packages with native extensions. Default is `false`. | + +### Secure Configuration Example -Python native extensions run by default as native binaries, with full access to the underlying system. -See [Embedding limitations](Native-Extensions.md#embedding-limitations) +This example shows how to configure a production-ready context with restricted permissions: -The context permissions needed to run native extensions are: ```java -.allowIO(IOAccess.ALL) -.allowCreateThread(true) -.allowNativeAccess(true) +Context context = Context.newBuilder("python") + .allowHostAccess(HostAccess.EXPLICIT) // Only explicitly exported objects + .allowIO(IOAccess.newBuilder() // Restrict to specific directory + .fileSystem(FileSystem.newDefaultFileSystem(Path.of("/safe/directory"))) + .build()) + .allowCreateThread(false) // No thread creation + .allowNativeAccess(false) // No native code + .build(); ``` + +### Development Configuration Example + +For development and testing environments, you might use a more permissive configuration: + +```java +Context context = Context.newBuilder("python") + .allowAllAccess(true) // Full access for development + .option("python.PosixModuleBackend", "java") // Use sandboxed backend + .build(); +``` + +> **Warning:** Using `allowAllAccess(true)` disables most security protections. Only use this in trusted environments or during development. For production deployments, configure specific permissions using the individual allow methods. + +## Python Native Extensions + +Python native extensions run by default as native binaries with full access to the underlying system. +This means they bypass the security controls described above. + +For more information about limitations when embedding native extensions, see [Embedding limitations](Embedding-Native-Extensions.md). diff --git a/docs/user/Interoperability.md b/docs/user/Interoperability.md index 5dec91c72b..be5d011c21 100644 --- a/docs/user/Interoperability.md +++ b/docs/user/Interoperability.md @@ -1,26 +1,38 @@ # Interoperability -Besides being primarily recommended to use in your Java application, GraalPy can interoperate with other Graal languages (languages implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)). -This means that you can use the objects and functions provided by those other languages directly from your Python scripts. +GraalPy can interoperate with Java and other Graal languages that are implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/). +This means that you can use other languages' objects and functions directly from your Python scripts. +This interoperability works in both directions. +Python can call other languages, and other languages can call Python code. -## Interacting with Java from Python scripts +> **Note for Python users:** The Java interoperability sections below require a JVM-based GraalPy runtime with the relevant Java classes on the classpath. The later `polyglot` sections describe the more general cross-language APIs for working with other Graal languages. + +## Call Java from Python Java is the host language of the JVM and runs the GraalPy interpreter itself. -To interoperate with Java from Python scripts, use the `java` module: +This means you can seamlessly access any Java class available in your classpath directly from Python. + +### Basic Java access + +Import the `java` module to access Java classes and methods: + ```python import java BigInteger = java.type("java.math.BigInteger") myBigInt = BigInteger.valueOf(42) -# a public Java methods can just be called +# Call Java methods directly myBigInt.shiftLeft(128) # returns a -# Java method names that are keywords in Python must be accessed using `getattr` +# Java method names that are Python keywords must be accessed using `getattr` getattr(myBigInt, "not")() # returns a byteArray = myBigInt.toByteArray() # Java arrays can act like Python lists assert len(byteArray) == 1 and byteArray[0] == 42 ``` -To import packages from the `java` namespace, you can also use the conventional Python import syntax: +### Importing Java packages + +You can import packages from the `java` namespace using conventional Python import syntax: + ```python import java.util.ArrayList from java.util import ArrayList @@ -32,14 +44,18 @@ al.add(12) assert list(al) == [1, 12] ``` +### Java module methods + In addition to the `type` built-in method, the `java` module exposes the following methods: -Built-in | Specification ---- | --- -`instanceof(obj, class)` | returns `True` if `obj` is an instance of `class` (`class` must be a foreign object class) -`is_function(obj)` | returns `True` if `obj` is a Java host language function wrapped using interop -`is_object(obj)` | returns `True` if `obj` if the argument is Java host language object wrapped using interop -`is_symbol(obj)` | returns `True` if `obj` if the argument is a Java host symbol, representing the constructor and static members of a Java class, as obtained by `java.type` +| Built-in | Specification +| --- | --- +| `instanceof(obj, class)` | Returns `True` if `obj` is an instance of `class` (`class` must be a foreign object class). | +| `is_function(obj)` | Returns `True` if `obj` is a Java host language function wrapped using interop. | +| `is_object(obj)` | Returns `True` if `obj` is a Java host language object wrapped using interop. | +| `is_symbol(obj)` | Returns `True` if `obj` is a Java host symbol, representing the constructor and static members of a Java class, as obtained by `java.type`. | + +Here's how to use these methods in practice: ```python ArrayList = java.type('java.util.ArrayList') @@ -51,11 +67,13 @@ assert java.is_function(my_list.add) assert java.instanceof(my_list, ArrayList) ``` -See [Polyglot Programming](https://github.com/oracle/graal/blob/master/docs/reference-manual/polyglot-programming.md) and [Embed Languages](https://github.com/oracle/graal/blob/master/docs/reference-manual/embedding/embed-languages.md) for more information about interoperability with other programming languages. +See the [Polyglot Programming](https://www.graalvm.org/latest/reference-manual/polyglot-programming/) and [Embed Languages](https://www.graalvm.org/latest/reference-manual/embedding/embed-languages/) documentation for more information about interoperability with other programming languages. + +## Call Foreign Objects from Python -## Interacting with foreign objects from Python scripts +When you use foreign objects in Python, GraalPy automatically makes them behave like their Python equivalents. -Foreign objects are given a Python class corresponding to their interop traits: +For example, a Java `ArrayList` acts like a Python `list`, and a Java `HashMap` acts like a Python `dict`: ```python from java.util import ArrayList, HashMap @@ -63,69 +81,155 @@ type(ArrayList()).mro() # => [, , [, , , ] ``` -This means all Python methods of these types are available on the corresponding foreign objects, which behave as close as possible as if they were Python objects: +This means you can use Python methods on foreign objects: ```python from java.util import ArrayList, HashMap +# ArrayList behaves like a Python list so you can use Python methods l = ArrayList() -l.append(1) # l: [1] -l.extend([2, 3]) # l: [1, 2, 3] -l.add(4) # l: [1, 2, 3, 4] # we can still call Java methods, this is calling ArrayList#add -l[1:3] # => [2, 3] -l.pop(1) # => 2; l: [1, 3, 4] -l.insert(1, 2) # l: [1, 2, 3, 4] -l == [1, 2, 3, 4] # True - +l.append(1) # Python list method - l: [1] +l.extend([2, 3]) # Python list method - l: [1, 2, 3] +l.add(4) # Java ArrayList method still works - l: [1, 2, 3, 4] +l[1:3] # Python slicing works - returns [2, 3] +l.pop(1) # Python list method - returns 2, l: [1, 3, 4] +l.insert(1, 2) # Python list method - l: [1, 2, 3, 4] +l == [1, 2, 3, 4] # Python comparison works - True + +# HashMap behaves like a Python dict so you can use Python methods h = HashMap() -h[1] = 2 # h: {1: 2} -h.setdefault(3, 4) # h: {1: 2, 3: 4} -h |= {3: 6} # {1: 2, 3: 6} -h == {1: 2, 3: 6} # True +h[1] = 2 # Python dict syntax - h: {1: 2} +h.setdefault(3, 4) # Python dict method - h: {1: 2, 3: 4} +h |= {3: 6} # Python dict operator - h: {1: 2, 3: 6} +h == {1: 2, 3: 6} # Python comparison works - True ``` -In case of a method defined both in Python and on the foreign object, the Python method wins. -To call the foreign method instead, use `super(type_owning_the_python_method, foreign_object).method(*args)`: +When a method is defined both in Python and on the foreign object, the Python's method takes precedence. + +To call the foreign method explicitly, use `super(type_owning_the_python_method, foreign_object).method(*args)`: ```python from java.util import ArrayList l = ArrayList() l.extend([5, 6, 7]) -l.remove(7) # Python list.remove +l.remove(7) # Calls Python list.remove() assert l == [5, 6] -super(list, l).remove(0) # ArrayList#remove(int index) +super(list, l).remove(0) # Calls Java's ArrayList.remove() assert l == [6] ``` -See [this section](#interop-types-to-python) for more interop traits and how they map to Python types. +See the [Interop Types to Python](#interop-types-to-python) section for more interop traits and how they map to Python types. -## Interacting with other dynamic languages from Python scripts +## Passing Binary Data Between Java and Python -More general, non-JVM specific interactions with other languages from Python scripts are achieved via the _polyglot_ API. +Passing binary data between Java and Python deserves attention: + +- Java code typically uses `byte[]` or `java.nio.ByteBuffer` +- Python code typically uses `bytes`, `bytearray`, `memoryview`, or file-like APIs such as `io.BytesIO` + +### Java to Python + +Raw Java `byte[]` are accessible as `list`-like objects in Python. +Only integral values that fit into a signed `byte` can be read from or written to such objects. +Python, on the other hand, usually exposes binary data as unsigned byte values. +To achieve the equivalent of a "re-interpreting cast", Java byte arrays should be passed to Python using `ByteBuffer.wrap(byte[])`: + +```java +import java.nio.ByteBuffer; +byte[] data = ...; +ByteBuffer buffer = ByteBuffer.wrap(data); // does not copy +context.getBindings("python").putMember("java_buffer", buffer); +``` + +Python can then use the object through buffer-oriented binary data APIs: + +```python +memoryview(java_buffer) # does not copy +bytes(java_buffer) # copies into an immutable Python-owned buffer +bytearray(java_buffer) # copies into a mutable Python-owned buffer +io.BytesIO(java_buffer) # copies into BytesIO's internal storage +``` + +### Python to Java + +Python `bytes` and other bytes-like objects can be interpreted like any `java.lang.List`. +Because Python bytes are usually unsigned, however, they cannot simply be converted via `Value#as(byte[].class)` if any values are larger than 127. +The Graal polyglot sdk provides `org.graalvm.polyglot.io.ByteSequence` as a target type to deal with this issue explicitly. + +```java +import org.graalvm.polyglot.Value; +import org.graalvm.polyglot.io.ByteSequence; +Value result = context.eval("python", "b'hello'"); +ByteSequence seq = result.as(ByteSequence.class); // does not copy +``` + +`ByteSequence` keeps the data as a Python-owned byte sequence without immediately copying. +It provides a `toByteArray()` method that deals with re-interpreting unsigned Python bytes as signed Java bytes. + +```java +import java.nio.charset.StandardCharsets; +import org.graalvm.polyglot.io.ByteSequence; +ByteSequence seq = result.as(ByteSequence.class); +byte[] bytes = seq.toByteArray(); // copies into Java byte[] +String s = new String(bytes, StandardCharsets.UTF_8); +``` + +## Call Other Languages from Python + +The _polyglot_ API allows non-JVM specific interactions with other languages from Python scripts. This includes all interactions with dynamic languages supported via the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/), including JavaScript and Ruby. +## Multithreading + +GraalPy implements the Python global interpreter lock (GIL), which prevents any two threads from executing Python code at the same instant. +When methods in other languages are called from Python, no Python code is running while the other language executes. +To give other Python threads a chance to run at this point in time, GraalPy releases the GIL around such foreign method calls by default. +This (un)locking of the GIL can impact performance negatively if the foreign code runs only for a very short while, however, so this behavior can be controlled per dynamic scope using Python context managers. + +```python +class JavaFile(io.FileIO): + def write(self, obj): + # Unlock the GIL when doing IO in Java + with polyglot.gil_locked_during_interop(False): + self.java_file.write(obj) + +with polyglot.gil_locked_during_interop(True): + # Keep the GIL locked when accessing Java maps, because those method calls will return very quickly + some_file.write(java_map.get(key1) + java_map.get(key2)) +``` + +Beware of always keeping the GIL locked. +That may lead to deadlocks if the foreign language attempts to wait on another thread of execution, and that thread tries to call back into Python. + ### Installing other dynamic languages -Other languages can be included by using their respective Maven dependencies in the same manner as GraalPy. -For example, if you have already configured a Maven project with GraalPy, add the following dependency to gain access to JavaScript: +To use other languages, like JavaScript, you need to add their Maven dependencies to your project. + +If you're using Maven with GraalPy, add the JavaScript dependency to your _pom.xml_ file: + ```xml org.graalvm.polyglot js - 24.2.0 + 25.0.3 ``` ### Examples +Here are practical examples of using the `polyglot` API to work with JavaScript from Python: + 1. Import the `polyglot` module to interact with other languages: ```python import polyglot @@ -143,7 +247,7 @@ libexec/graalpy-polyglot-get js polyglot.eval(path="./my_js_file.js", language="js") ``` -4. Import a glocal value from the polyglot scope: +4. Import a global value from the polyglot scope: ```python Math = polyglot.import_value("JSMath") ``` @@ -179,19 +283,21 @@ libexec/graalpy-polyglot-get js This program matches Python strings using the JavaScript regular expression object. Python reads the captured group from the JavaScript result and checks for a substring in it. -## Exporting Python Objects to other Languages +## Export Python Objects -The `polyglot` module can be used to expose Python objects to JVM languages and other Graal languages (languages implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)). +Use the `polyglot` module to expose Python objects to JVM languages and other Graal languages (languages implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)). -1. You can export some object from Python to other languages so they can import it: +This allows other languages to call your Python code directly. + +1. You can export a Python object so other languages can access it: ```python import ssl polyglot.export_value(value=ssl, name="python_ssl") ``` - - Then use it in (for example) from JavaScript code: + + Then use it, for example, from JavaScript code: ```js - Polyglot.import('python_ssl).get_server_certificate(["oracle.com", 443]) + Polyglot.import('python_ssl').get_server_certificate(["oracle.com", 443]) ``` 2. You can decorate a Python function to export it by name: @@ -201,13 +307,14 @@ The `polyglot` module can be used to expose Python objects to JVM languages and return "Hello from Python!" ``` - Then use it (for example) from Java code: + Then use it, for example, from Java code: ```java import org.graalvm.polyglot.*; + import org.graalvm.python.embedding.GraalPyResources; class Main { public static void main(String[] args) { - try (var context = Context.create()) { + try (var context = GraalPyResources.createContext()) { context.eval(Source.newBuilder("python", "file:///python_script.py").build()); String result = context. @@ -221,9 +328,9 @@ The `polyglot` module can be used to expose Python objects to JVM languages and } ``` -## Mapping Types between Python and Other Languages +## Types Mapping -The interop protocol defines different "types/traits" which can overlap in all kinds of ways and have restrictions on how they can interact with Python. +The interop protocol defines different types and traits that determine foreign objects behavior and restrictions when used in Python. ### Interop Types to Python @@ -231,69 +338,73 @@ All foreign objects passed into Python have the Python type `polyglot.ForeignObj Types not listed in the table below have no special interpretation in Python. -| Interop Type | Inherits from | Python Interpretation | -|:---------------|:----------------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `null` | ForeignNone, `NoneType` | `null` is like `None`. Important to know: interop `null` values are all identical to `None`. JavaScript defines two "null-like" values; `undefined` and `null`, which are *not* identical, but when passed to Python, they are treated so. | -| `boolean` | ForeignBoolean, ForeignNumber | `boolean` behaves like Python booleans, including the fact that in Python, all booleans are also integers (1 and 0 for true and false, respectively). | -| `number` | ForeignNumber | `number` behaves like Python numbers. Python only has one integer and one floating point type, but ranges are imported in some places such as typed arrays. | -| `string` | ForeignString, `str` | Behaves in the same way as a Python string. | -| `buffer` | ForeignObject | Buffers are also a concept in Python's native API (albeit slightly different). Interop buffers are treated in the same was as Python buffers in some places (such as `memoryview`) to avoid copies of data. | -| `array` | ForeignList, `list` | An `array` behaves like a Python `list`. | +| Interop Type | Inherits from | Python Interpretation | +| :------------- | :-------------------------------- | :------------------------------------------------------------------------------------------------------------------ | +| `array` | ForeignList, `list` | An `array` behaves like a Python `list`. Just like Python lists, the size must fit into a 32-bit signed integer. | +| `boolean` | ForeignBoolean, ForeignNumber | `boolean` behaves like Python booleans, including the fact that in Python, all booleans are also integers (`1` and `0` for `true` and `false`, respectively). | +| `buffer` | ForeignObject | Buffers work like Python buffer objects (such as those used with `memoryview`) to avoid copying data. | +| `exception` | ForeignException, `BaseException` | An `exception` can be caught in a generic `except` clause. | +| `executable` | ForeignExecutable | An `executable` object can be executed as a function, but never with keyword arguments. | | `hash` | ForeignDict, `dict` | A `hash` behaves like a Python `dict`, with any "hashable" object as a key. "Hashable" follows Python semantics: generally every interop type with an identity is deemed "hashable". | -| `members` | ForeignObject | An object of type `members` can be read using conventional Python `.` notation or `getattr` and related functions. | +| `instantiable` | ForeignInstantiable | An `instantiable` object can be called just like a Python type, but never with keyword arguments. | | `iterable` | ForeignIterable | An `iterable` is treated in the same way as any Python object with an `__iter__` method. That is, it can be used in a loop and other places that accept Python iterables. | | `iterator` | ForeignIterator, `iterator` | An `iterator` is treated in the same way as any Python object with a `__next__` method. | -| `exception` | ForeignException, `BaseException` | An `exception` can be caught in a generic `except` clause. | +| `members` | ForeignObject | Objects with `members` can be accessed using Python dot notation (`.`) or `getattr()`. | | `MetaObject` | ForeignAbstractClass | Meta objects can be used in subtype and `isinstance` checks. | -| `executable` | ForeignExecutable | An `executable` object can be executed as a function, but never with keyword arguments. | -| `instantiable` | ForeignInstantiable | An `instantiable` object can be called just like a Python type, but never with keyword arguments. | +| `null` | ForeignNone, `NoneType` | `null` behaves like Python `None`. All interop null values (including JavaScript `undefined` and `null`) are treated as `None` in Python. | +| `number` | ForeignNumber | `number` behaves like Python numbers (`int` and `float`). Foreign ranges are imported in some places such as typed arrays. | +| `string` | ForeignString, `str` | Behaves in the same way as a Python string. | Foreign numbers inherit from `polyglot.ForeignNumber` and not `int` or `float` because `InteropLibrary` has currently no way to differentiate integers and floats. + However: + * When foreign numbers are represented as Java primitives `byte`, `short`, `int`, `long`, they are considered Python `int` objects. * When foreign numbers are represented as Java primitives `float`, `double`, they are considered Python `float` objects. -* When foreign booleans re represented as Java primitives `boolean`, they are considered Python `bool` objects. +* When foreign booleans are represented as Java primitives `boolean`, they are considered Python `bool` objects. ### Python to Interop Types -| Interop Type | Python Interpretation | -|:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `null` | Only `None`. | -| `boolean` | Only subtypes of Python `bool`. Note that in contrast to Python semantics, Python `bool` is *never* also an interop number. | -| `number` | Only subtypes of `int` and `float`. | -| `string` | Only subtypes of `str`. | +The following table shows how Python objects are converted to interop types when passed to other languages: + +| Interop Type | Python Interpretation | +| :------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------- | | `array` | Any object with `__getitem__` and `__len__` methods, but not if it also has `keys`, `values`, and `items` methods (in the same way that `dict` does.) | +| `boolean` | Only subtypes of Python `bool`. Note that in contrast to Python semantics, Python `bool` is *never* also an interop number. | +| `exception` | Any Python `BaseException` subtype. | +| `executable` | Any Python object with a `__call__` method. | | `hash` | Only subtypes of `dict`. | -| `members` | Any Python object. Note that the rules for readable/writable are a bit ad-hoc, since checking that is not part of the Python MOP. | -| `iterable` | Any Python object that has `__iter__` or a `__getitem__` methods. | +| `instantiable` | Any Python `type`. | +| `iterable` | Any Python object that has `__iter__` or `__getitem__` methods. | | `iterator` | Any Python object with a `__next__` method. | -| `exception` | Any Python `BaseException` subtype. | +| `members` | Any Python object. Note that the rules for readable/writable are a bit ad-hoc, since checking that is not part of the Python MOP. | | `MetaObject` | Any Python `type`. | -| `executable` | Any Python object with a `__call__` method. | -| `instantiable` | Any Python `type`. | +| `null` | Only `None`. | +| `number` | Only subtypes of `int` and `float`. | +| `string` | Only subtypes of `str`. | -## The Interoperability Extension API +## Interoperability Extension API -It is possible to extend the interoperability protocol directly from Python via a simple API defined in the `polyglot` module. -The purpose of this API is to enable custom / user defined types to take part in the interop ecosystem. -This is particularly useful for external types which are not compatible by default with the interop protocol. -An example in this sense are the `numpy` numeric types (for example, `numpy.int32`) which are not supported by default by the interop protocol. +You can extend the interoperability protocol directly from Python through a simple API defined in the `polyglot` module. +This API lets you define interoperability behavior for custom or user-defined types that are not automatically supported. +This is particularly useful for external types which are not compatible by default with the interop protocol. +For example, `numpy` numeric types (for example, `numpy.int32`) which are not supported by default by the interop protocol need special handling to work properly with other languages. -### The API +The `polyglot` module provides these functions for customizing interop behavior: -| Function | Description | +| Function | Description | |:--------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| register_interop_behavior | Takes the receiver **type** as first argument. The remainder keyword arguments correspond to the respective interop messages. Not All interop messages are supported. | -| get_registered_interop_behavior | Takes the receiver **type** as first argument. Returns the list of extended interop messages for the given type. | -| @interop_behavior | Class decorator, takes the receiver **type** as only argument. The interop messages are extended via **static** methods defined in the decorated class (supplier). | -| register_interop_type | Takes a `foreign class` and `python class` as positional arguments and `allow_method_overwrites` as optional argument (default: `False`). Every instance of foreign class is then treated as an instance of the given python class. | -| @interop_type | Class decorator, takes the `foreign class` and optionally `allow_method_overwrites` as arguments. The instances of foreign class will be treated as an instance of the annotated python class. | +| `register_interop_behavior` | Takes the receiver **type** as the first argument. The remaining keyword arguments correspond to the respective interop messages. Not all interop messages are supported. | +| `get_registered_interop_behavior` | Takes the receiver **type** as the first argument. Returns the list of extended interop messages for the given type. | +| `@interop_behavior` | Class decorator that takes the receiver **type** as the only argument. The interop messages are extended via **static** methods defined in the decorated class (supplier). | +| `register_interop_type` | Takes a `foreign class` and `python class` as positional arguments and `allow_method_overwrites` as an optional argument (default: `False`). Every instance of the foreign class is then treated as an instance of the given python class. | +| `@interop_type` | Class decorator that takes the `foreign class` and optionally `allow_method_overwrites` as arguments. The instances of the foreign class will be treated as an instance of the annotated python class. | -### Usage Examples +### Interop behavior usage example -#### Interop Behavior +You can use the `register_interop_behavior` API to add custom interop behavior to existing types: -A simple `register_interop_behavior` API is available to register interop behaviors for existing types: +For example, to make `numpy.int32` work properly with other languages: ```python import polyglot @@ -314,9 +425,11 @@ polyglot.register_interop_behavior(numpy.int32, ) ``` -The `@interop_behavior` decorator may be more convenient when declaring more behaviors. -Interop message extension is achieved via **static** methods of the decorated class. -The names of the static methods are identical to the keyword names expected by `register_interop_behavior`. +Alternatively, you can use the `@interop_behavior` decorator when you need to define multiple behaviors for a type. +With this decorator, you define interop behaviors using **static** methods in a decorated class. +The static method names must match the keyword argument names used by `register_interop_behavior`. + +The following example uses the decorator approach for `numpy.float64`: ```python from polyglot import interop_behavior @@ -324,7 +437,7 @@ import numpy @interop_behavior(numpy.float64) -class Int8InteropBehaviorSupplier: +class Float64InteropBehaviorSupplier: @staticmethod def is_number(_): return True @@ -345,10 +458,11 @@ import java.nio.file.Files; import java.nio.file.Path; import org.graalvm.polyglot.Context; +import org.graalvm.python.embedding.GraalPyResources; class Main { public static void main(String[] args) { - try (var context = Context.create()) { + try (var context = GraalPyResources.createContext()) { context.eval("python", Files.readString(Path.of("path/to/interop/behavior/script.py"))); assert context.eval("python", "numpy.float64(12)").asDouble() == 12.0; assert context.eval("python", "numpy.int32(12)").asByte() == 12; @@ -356,12 +470,15 @@ class Main { } } ``` -#### Interop Types + +### Interop types usage example The `register_interop_type` API allows the usage of python classes for foreign objects. -The class of such a foreign object will no longer be `polyglot.ForeignObject` or `polyglot.Foreign*`. -Instead, it will be a generated class with the registered python classes and `polyglot.ForeignObject` as super class. -This allows custom mapping of foreign methods and attributes to Python's magic methods or more idiomatic Python code. +When you register a Python class for a foreign type, instances of that foreign object will no longer have the default `polyglot.ForeignObject` or `polyglot.Foreign* class`. +Instead, GraalPy creates a new generated class that inherits from both your Python class and `polyglot.ForeignObject`. +This lets you add Python methods to foreign objects, and map foreign functionality to Python's magic methods or more idiomatic Python patterns. + +This is a simple Java class to customize: ```java package org.example; @@ -369,7 +486,7 @@ package org.example; class MyJavaClass { private int x; private int y; - + public MyJavaClass(int x, int y) { this.x = x; this.y = y; @@ -385,14 +502,17 @@ class MyJavaClass { } ``` +The following snippet sets up the Java environment and makes the object available to Python: + ```java import org.example.MyJavaClass; - +import org.graalvm.python.embedding.GraalPyResources; + class Main { public static void main(String[] args) { MyJavaClass myJavaObject = new MyJavaClass(42, 17); - try (var context = Context.create()) { + try (var context = GraalPyResources.createContext()) { // myJavaObject will be globally available in example.py as my_java_object context.getBindings("python").putMember("my_java_object", myJavaObject); context.eval(Source.newBuilder("python", "example.py")); @@ -401,6 +521,8 @@ class Main { } ``` +This snippet states how to customize the Java object's behavior using Python classes: + ```python # example.py import java @@ -424,11 +546,11 @@ print(type(my_java_object).mro()) # [polyglot.Java_org.example.MyJavaClass_gener class MyPythonClassTwo: def get_tuple(self): return (self.getY(), self.getX()) - + def __str__(self): - return f"MyJavaInstance(x={self.getX()}, y={self.getY()}" + return f"MyJavaInstance(x={self.getX()}, y={self.getY()})" -# If 'allow_method_overwrites=True' is not given, this would lead to an error due to the method conflict of 'get_tuple' +# If 'allow_method_overwrites=True' is not given, this would lead to an error due to the method conflict of 'get_tuple' register_interop_type(foreign_class, MyPythonClassTwo, allow_method_overwrites=True) # A newly registered class will be before already registered classes in the mro. @@ -439,7 +561,8 @@ print(my_java_object.get_tuple()) # (17, 42) print(my_java_object) # MyJavaInstance(x=42, y=17) ``` -Registering classes may be more convenient with `@interop_type`: +For simpler cases, you can use the `@interop_type` decorator: + ```python import java from polyglot import interop_type @@ -454,65 +577,66 @@ class MyPythonClass: ### Supported messages -The majority (with some exceptions) of the interop messages are supported by the interop behavior extension API, as shown in the table below. -The naming convention for the `register_interop_behavior` keyword arguments follows the _snake_case_ naming convention, i.e. the interop `fitsInLong` message -becomes `fits_in_long` and so on. Each message can be extended with a **pure python function** (default keyword arguments, free vars and cell vars are not allowed) or a **boolean constant**. -The table below describes the supported interop messages: - -| Message | Extension argument name | Expected return type | -|:-------------------------|:----------------------------|-------------------------------------------------------------------------------------------------------| -| isBoolean | is_boolean | bool | -| isDate | is_date | bool | -| isDuration | is_duration | bool | -| isIterator | is_iterator | bool | -| isNumber | is_number | bool | -| isString | is_string | bool | -| isTime | is_time | bool | -| isTimeZone | is_time_zone | bool | -| isExecutable | is_executable | bool | -| fitsInBigInteger | fits_in_big_integer | bool | -| fitsInByte | fits_in_byte | bool | -| fitsInDouble | fits_in_double | bool | -| fitsInFloat | fits_in_float | bool | -| fitsInInt | fits_in_int | bool | -| fitsInLong | fits_in_long | bool | -| fitsInShort | fits_in_short | bool | -| asBigInteger | as_big_integer | int | -| asBoolean | as_boolean | bool | -| asByte | as_byte | int | -| asDate | as_date | 3-tuple with the following elements: (`year`: int, `month`: int, `day`: int) | -| asDouble | as_double | float | -| asDuration | as_duration | 2-tuple with the following elements: (`seconds`: long, `nano_adjustment`: long) | -| asFloat | as_float | float | -| asInt | as_int | int | -| asLong | as_long | int | -| asShort | as_short | int | -| asString | as_string | str | -| asTime | as_time | 4-tuple with the following elements: (`hour`: int, `minute`: int, `second`: int, `microsecond`: int) | -| asTimeZone | as_time_zone | a string (the timezone) or int (utc delta in seconds) | -| execute | execute | object | -| readArrayElement | read_array_element | object | -| getArraySize | get_array_size | int | -| hasArrayElements | has_array_elements | bool | -| isArrayElementReadable | is_array_element_readable | bool | -| isArrayElementModifiable | is_array_element_modifiable | bool | -| isArrayElementInsertable | is_array_element_insertable | bool | -| isArrayElementRemovable | is_array_element_removable | bool | -| removeArrayElement | remove_array_element | NoneType | -| writeArrayElement | write_array_element | NoneType | -| hasIterator | has_iterator | bool | -| hasIteratorNextElement | has_iterator_next_element | bool | -| getIterator | get_iterator | a python iterator | -| getIteratorNextElement | get_iterator_next_element | object | -| hasHashEntries | has_hash_entries | bool | -| getHashEntriesIterator | get_hash_entries_iterator | a python iterator | -| getHashKeysIterator | get_hash_keys_iterator | a python iterator | -| getHashSize | get_hash_size | int | -| getHashValuesIterator | get_hash_values_iterator | a python iterator | -| isHashEntryReadable | is_hash_entry_readable | bool | -| isHashEntryModifiable | is_hash_entry_modifiable | bool | -| isHashEntryInsertable | is_hash_entry_insertable | bool | -| isHashEntryRemovable | is_hash_entry_removable | bool | -| readHashValue | read_hash_value | object | -| writeHashEntry | write_hash_entry | NoneType | -| removeHashEntry | remove_hash_entry | NoneType | +Most interop messages are supported by the interop behavior extension API. +The naming convention for `register_interop_behavior` keyword arguments uses _snake_case_, so the interop `fitsInLong` message becomes `fits_in_long`. +Each message can be extended with either a **pure Python function** (no default keyword arguments, free vars, or cell vars allowed) or a **boolean constant**. + +The following table describes the supported interop messages: + +| Message | Extension argument name | Expected return type | +| :------------------------- | :---------------------------- | :----------------------------------------------------------------------------------- | +| `isBoolean` | `is_boolean` | `bool` | +| `isDate` | `is_date` | `bool` | +| `isDuration` | `is_duration` | `bool` | +| `isExecutable` | `is_executable` | `bool` | +| `isIterator` | `is_iterator` | `bool` | +| `isNumber` | `is_number` | `bool` | +| `isString` | `is_string` | `bool` | +| `isTime` | `is_time` | `bool` | +| `isTimeZone` | `is_time_zone` | `bool` | +| `fitsInBigInteger` | `fits_in_big_integer` | `bool` | +| `fitsInByte` | `fits_in_byte` | `bool` | +| `fitsInDouble` | `fits_in_double` | `bool` | +| `fitsInFloat` | `fits_in_float` | `bool` | +| `fitsInInt` | `fits_in_int` | `bool` | +| `fitsInLong` | `fits_in_long` | `bool` | +| `fitsInShort` | `fits_in_short` | `bool` | +| `asBigInteger` | `as_big_integer` | `int` | +| `asBoolean` | `as_boolean` | `bool` | +| `asByte` | `as_byte` | `int` | +| `asDate` | `as_date` | tuple: (`year`: int, `month`: int, `day`: int) | +| `asDouble` | `as_double` | `float` | +| `asDuration` | `as_duration` | tuple: (`seconds`: int, `nano_adjustment`: int) | +| `asFloat` | `as_float` | `float` | +| `asInt` | `as_int` | `int` | +| `asLong` | `as_long` | `int` | +| `asShort` | `as_short` | `int` | +| `asString` | `as_string` | `str` | +| `asTime` | `as_time` | tuple: (`hour`: int, `minute`: int, `second`: int, `microsecond`: int) | +| `asTimeZone` | `as_time_zone` | `str` (timezone name) or `int` (UTC delta in seconds) | +| `execute` | `execute` | `object` | +| `readArrayElement` | `read_array_element` | `object` | +| `getArraySize` | `get_array_size` | `int` | +| `hasArrayElements` | `has_array_elements` | `bool` | +| `isArrayElementReadable` | `is_array_element_readable` | `bool` | +| `isArrayElementModifiable` | `is_array_element_modifiable` | `bool` | +| `isArrayElementInsertable` | `is_array_element_insertable` | `bool` | +| `isArrayElementRemovable` | `is_array_element_removable` | `bool` | +| `removeArrayElement` | `remove_array_element` | `None` | +| `writeArrayElement` | `write_array_element` | `None` | +| `hasIterator` | `has_iterator` | `bool` | +| `hasIteratorNextElement` | `has_iterator_next_element` | `bool` | +| `getIterator` | `get_iterator` | Python iterator | +| `getIteratorNextElement` | `get_iterator_next_element` | `object` | +| `hasHashEntries` | `has_hash_entries` | `bool` | +| `getHashEntriesIterator` | `get_hash_entries_iterator` | Python iterator | +| `getHashKeysIterator` | `get_hash_keys_iterator` | Python iterator | +| `getHashSize` | `get_hash_size` | `int` | +| `getHashValuesIterator` | `get_hash_values_iterator` | Python iterator | +| `isHashEntryReadable` | `is_hash_entry_readable` | `bool` | +| `isHashEntryModifiable` | `is_hash_entry_modifiable` | `bool` | +| `isHashEntryInsertable` | `is_hash_entry_insertable` | `bool` | +| `isHashEntryRemovable` | `is_hash_entry_removable` | `bool` | +| `readHashValue` | `read_hash_value` | `object` | +| `writeHashEntry` | `write_hash_entry` | `None` | +| `removeHashEntry` | `remove_hash_entry` | `None` | diff --git a/docs/user/Native-Extensions.md b/docs/user/Native-Extensions.md index 5746d1372a..094042216f 100644 --- a/docs/user/Native-Extensions.md +++ b/docs/user/Native-Extensions.md @@ -7,48 +7,3 @@ Packages that use the native API must be built and installed with GraalPy, and t For best results, it is crucial that you only use the `pip` command that comes preinstalled in GraalPy virtual environments to install packages. The version of `pip` shipped with GraalPy applies additional patches to packages upon installation to fix known compatibility issues and it is preconfigured to use an additional repository from graalvm.org where we publish a selection of prebuilt wheels for GraalPy. Please do not update `pip` or use alternative tools such as `uv`. - -## Embedding limitations - -Python native extensions run by default as native binaries, with full access to the underlying system. -This has a few implications: - -1. Native code is entirely unrestricted and can circumvent any security protections Truffle or the JVM may provide. -2. Native data structures are not subject to the Java GC and the combination of them with Java data structures may lead to increased memory pressure or memory leaks. -3. Native libraries generally cannot be loaded multiple times into the same process, and they may contain global state that cannot be safely reset. - -### Full Native Access - -The Context API allows to set options such as `allowIO`, `allowHostAccess`, `allowThreads` and more on the created contexts. -To use Python native extensions on GraalPy, the `allowNativeAccess` option must be set to true, but this opens the door to full native access. -This means that while Python code may be denied access to the host file system, thread- or subprocess creation, and more, the native extension is under no such restriction. - -### Memory Management - -Python C extensions, like the CPython reference implementation, use reference counting for memory management. -This is fundamentally incompatible with JVM GCs. - -Java objects may end up being referenced from native data structures which the JVM cannot trace, so to avoid crashing, GraalPy keeps such Java objects strongly referenced. -To avoid memory leaks, GraalPy implements a cycle detector that regularly traces references between Java objects and native objects that have crossed between the two worlds and cleans up strong references that are no longer needed. - -On the other side, reference-counted native extension objects may end up being referenced from Java objects, and in this case GraalPy bumps their reference count to make them unreclaimable. -Any such references to native extension objects are registered with a `java.lang.ref.WeakReference` and when the JVM GC has collected the owning Java object, the reference count of the native object is reduced again. - -Both of these mechanisms together mean there is additional delay between objects becoming unreachable and their memory being reclaimed when compared to the CPython implementation. -This can manifest in increased memory usage when running C extensions. -You can tweak the Context options `python.BackgroundGCTaskInterval`, `python.BackgroundGCTaskThreshold`, and `BackgroundGCTaskMinimum` to mitigate this. -They control the minimum interval between cycle detections, how much RSS memory must have increased since the last time to trigger the cycle detector, and the absolute minimum RSS under which no cycle detection should be done. -You can also manually trigger the detector with the Python `gc.collect()` call. - -### Multi-Context and Native Libraries - -Using C extensions in multiple contexts is only possible on Linux for now, and many C extensions still have issues in this mode. -You should test your applications thoroughly if you want to use this feature. -There are many possibilities for native code to sidestep the library isolation through other process-wide global state, corrupting the state and leading to incorrect results or crashing. -The implementation also relies on `venv` to work, even if you are not using external packages. - -To support creating multiple GraalPy contexts that access native modules within the same JVM or Native Image, we need to isolate them from each other. -The current strategy for this is to copy the libraries and modify them such that the dynamic library loader of the operating system will isolate them for us. -To do this, all GraalPy contexts in the same process (not just those in the same engine!) must set the `python.IsolateNativeModules` option to `true`. - -For more details on this, see [our implementation details](https://github.com/oracle/graalpython/blob/master/docs/contributor/IMPLEMENTATION_DETAILS.md#c-extension-copying). diff --git a/docs/user/Native-Images-with-Python.md b/docs/user/Native-Images-with-Python.md index 1c16f43f66..d897c6dfbe 100644 --- a/docs/user/Native-Images-with-Python.md +++ b/docs/user/Native-Images-with-Python.md @@ -1,92 +1,69 @@ # Native Executables with Python -GraalPy supports GraalVM Native Image to generate native binaries of Java applications that use GraalPy. +GraalPy supports GraalVM Native Image to generate native binaries of Java applications that embed Python code. -## Quickstart +## Building Executables with Python -If you started with the [Maven archetype](README.md), the generated _pom.xml_ makes it easy to generate a native executable using the [Maven plugin for Native Image building](https://graalvm.github.io/native-build-tools/latest/maven-plugin.html). +If you started with the [Maven archetype](Embedding-Getting-Started.md#maven), the generated _pom.xml_ file already includes the necessary configuration for creating a native executable using the [Maven plugin for Native Image building](https://graalvm.github.io/native-build-tools/latest/maven-plugin.html). To build the application, run: + ```bash mvn -Pnative package ``` -The command packages the project and creates a native executable. -Take a look at the generated files _pom.xml_ and _Main.java_. -They are documented to explain how Python resources are included in the resulting binary. -The generated project should be viewed as a starting point. -It includes the entire Python standard library, so the Python code can invoke all of the standard library code. -The resources can be manually pruned to reduce the included Python libraries to the necessary amount, reducing both the size of the package and the time to start up. -This Java example demonstrates some useful default options for the Python context, but other settings may be desirable to further control what the Python code is allowed to do. +This command packages the project and creates a native executable. -## Reducing Binary Size +The generated _pom.xml_ and _Main.java_ files explain how Python resources are included in the resulting binary. +The generated project serves as a starting point and includes the entire Python standard library by default, allowing your Python code to use any standard library modules. +You can manually remove unused Python libraries to reduce both the executable size and startup time. +The created example demonstrates useful default options for the Python context, but you can adjust these settings to control what your Python code can access. -Python is a large language. -"Batteries included" has long been a core tenet of CPython. -As a compatible replacement, GraalPy includes most of those "batteries" as well. -This can result in significant increases in binary size when including GraalPy in a Java application. - -Only you as the developer know your specific embedding scenario. -The defaults may include much more than needed for any specific application. -An embedded Python-in-Java application usually has more limited use cases for the Python interpreter than the full GraalPy distribution, and often you can know ahead of time whether certain features are needed. -Some features (for example, cryptographic algorithms or socket access) may even be undesirable to include in some cases. -Thus, when embedding GraalPy in a Java application, the binary size can be reduced and security improved by excluding components of the Python language. - -### Excluding Python Components - -GraalPy defines a few system properties that can be passed on the `native-image` command line to exclude aspects of the language. -The options can, when taken together, reduce the size of the executable by around 20%. -These are: - -* `python.WithoutSSL=true` - This option removes the `ssl` module. - If no secure network access or certificate checking is required, this removes Java's SSL classes and the BouncyCastle library. -* `python.WithoutDigest=true` - This option removes the `_md5`, `_sha1`, `_sha256`, `_sha512`, `_sha3`, and `_hashlib` modules. - This removes the direct usages of `java.security.MessageDigest` and `javax.crypto.Mac` from GraalPy. -* `python.WithoutPlatformAccess=true` - This removes the `signal` and `subprocess` modules, removes accesses to process properties such as the Unix UID and GID, or setting the Java default time zone. - This has no significant impact on binary size, but if these are unwanted capabilities that are dynamically disabled with context options anyway, they can also be removed ahead of time. -* `python.WithoutCompressionLibraries=true` - This removes the `zlib`, `lzma`, `bzip2`, and `zipimporter` modules and related classes. - These modules have both native and pure Java implementations (the former for performance, the latter for better sandboxing); however, if they are not needed, they can be removed entirely. -* `python.WithoutNativePosix=true` - The default `os` module backend is a pure Java implementation when GraalPy is embedded rather than run via its launcher. - The native POSIX backend of GraalPy is recommended only for 100% compatibility with CPython's POSIX interfaces, and if not used, can be removed from the build with this option. -* `python.WithoutJavaInet=true` - The Java implementation of Python's `socket` module is based on Java's networking classes. - If network access is denied for an embedding scenario, this option can reduce the binary size further. -* `python.AutomaticAsyncActions=false` - Signal handling, Python weak reference callbacks, and cleaning up native resources is usually achieved automatically by spawning GraalPy daemon threads that submit safepoint actions to the Python main thread. - This uses an `ExecutorService` with a thread pool. - If you want to disallow such extra threads or avoid pulling in `ExecutorService` and related classes, then set this property to `false` and retrieve the `PollPythonAsyncActions` object from the context's polyglot bindings. - This object is executable and can be used to trigger Python asynchronous actions at the locations you desire. +## Reducing Binary Size +Python is a feature-rich language with an extensive standard library. +This can result in large native executables when embedding GraalPy in Java applications. +You can significantly reduce the size by excluding components your application doesn't need by considering what your Python code actually uses. ### Removing Pre-initialized Python Heap -Another useful option to reduce the size of the native executable is to omit a pre-initialized Python context from the executable. -By default, a default Python context is already pre-initialized and ready for immediate execution. -This can lead to slightly improved startup, at the cost of including a few thousand Python objects in the binary. -In embedded applications that use a custom polyglot engine to allow context sharing, the pre-initialized context cannot be used at all, and including those objects is wasted. -The pre-initialized heap can be omitted by passing the following to the `native-image` command: +By default, GraalPy includes a pre-initialized Python context in the executable for faster startup. +Disabling this reduces the binary size by about 15MiB. +You should remove this if: + +- You are creating more than one context +- Binary size is more important than a slight startup delay + +To remove the pre-initialized heap, add this flag to your build configuration: ```bash --Dimage-build-time.PreinitializeContexts= +-Dpolyglot.image-build-time.PreinitializeContexts= ``` ### Disabling Runtime Compilation of Python Code -If binary size is significantly more important than execution speed (which may be the case if all Python scripts are expected to be short running, perform a lot of I/O, or scripts are rarely executed more than once), it may make sense to disable JIT compilation entirely. +If binary size is significantly more important than execution speed, you can disable JIT compilation entirely. +This will reduce binary size by around 40%. +You should use this if: + +- Your Python scripts are very short-running +- Performance is not critical +- Your scripts spend most time on I/O operations + Be aware that this may significantly impact your Python performance, so be sure to test the runtime behavior of your actual use cases when choosing to use this option. + This can be achieved by passing the following options: ```bash --Dtruffle.TruffleRuntime=com.oracle.truffle.api.impl.DefaultTruffleRuntime \ +-Dtruffle.TruffleRuntime=com.oracle.truffle.api.impl.DefaultTruffleRuntime -Dpolyglot.engine.WarnInterpreterOnly=false ``` ### Summary -Combining all of these approaches can halve the size of the GraalPy binary. -Every embedded application is different and the code pulled in by the rest of the Java code also matters, so combinations of these options should be tried to determine which effect they have in a specific instance. +Combining these approaches can reduce the binary size by 50% or more. +Since every application is different, experiment with different combinations to find what works best for your specific use case. ## Shipping Python Packages -Our Maven archetype by default is set up to include all needed Python files in the native binary itself, so the image is self-contained. - -In custom embeddings, the Python standard library is copied next to the native image. -When moving the native image, the standard library folder needs to be kept next to it. +GraalPy Maven archetype by default is set up to include all needed Python files in the native binary itself, so the image is self-contained. diff --git a/docs/user/Performance.md b/docs/user/Performance.md index fa84d2be43..7d9c1e0dc3 100644 --- a/docs/user/Performance.md +++ b/docs/user/Performance.md @@ -17,6 +17,16 @@ Many Python packages from the machine learning or data science ecosystems contai This code benefits little from GraalPy's JIT compilation and suffers from having to emulate CPython implementation details on GraalPy. When many C extensions are involved, performance can vary a lot depending on the specific interactions of native and Python code. +### Launcher JIT Presets + +The GraalPy launcher provides `-X jit=0|1|2` presets for common startup-heavy and throughput-oriented use cases. The launcher defaults to `-X jit=1` when no `-X jit=...` preset is specified: + +- `-X jit=0` disables runtime compilation and minimizes memory usage for tiny one-shot runs. +- `-X jit=1` keeps compilation enabled, but favors small command line applications with a single compiler thread and higher compilation thresholds. +- `-X jit=2` keeps compilation enabled with throughput mode and the same higher thresholds for hotter or longer-running workloads. + +These presets are launcher conveniences that expand to engine options. They can still be combined with explicit `--engine.*` options when more detailed tuning is needed. + ## Code Loading Performance and Footprint It takes time to parse Python code so when using GraalPy to embed another language in Python, observe the general advice for embedding Graal languages related to [code caching](https://www.graalvm.org/latest/reference-manual/embed-languages/#code-caching-across-multiple-contexts). diff --git a/docs/user/Platform-Support.md b/docs/user/Platform-Support.md new file mode 100644 index 0000000000..bf8f1ef1a5 --- /dev/null +++ b/docs/user/Platform-Support.md @@ -0,0 +1,7 @@ +### Platform Support + +GraalPy is mostly written in Java and Python, but the Python package ecosystem is rich in native packages that need platform specific support via native libraries that expose platform-specific APIs. +The main operating system is Oracle Linux, the CPU architectures are AMD64 and ARM, and the primary JDK is Oracle GraalVM. +**Linux is recommended for getting started with GraalPy.** Windows and macOS with GraalVM JDK are less well tested, and outside of those combinations only basic test coverage is provided. +As macOS and other platforms are not prioritized, some GraalPy features may not work on these platforms. +See [Test Tiers](../user/Test-Tiers.md) for a detailed breakdown. \ No newline at end of file diff --git a/docs/user/Python-Runtime.md b/docs/user/Python-Runtime.md index 2415adcb7f..b8730d9354 100644 --- a/docs/user/Python-Runtime.md +++ b/docs/user/Python-Runtime.md @@ -1,159 +1,19 @@ -# Testing Python Applications and Packages on GraalPy +# GraalPy Runtime Guide -## Choosing the GraalPy Runtime +This content has been merged into [Using GraalPy as a Standalone Python Runtime](Standalone-Getting-Started.md). -GraalPy provides a Python 3.11 compliant runtime. -A primary goal is to support PyTorch, SciPy, and their constituent libraries, as well as to work with other data science and machine learning libraries from the rich Python ecosystem. -GraalPy is distributed as an ahead-of-time compiled native executable, compact in size. +## Choosing a GraalPy Distribution -GraalPy provides the following capabilities: +See [Choosing a GraalPy Distribution](Standalone-Getting-Started.md#choosing-a-graalpy-distribution). -* CPython-compatible distribution. This is the most compatible option to test Python code on GraalPy, since it most closely resembles the structure of CPython distributions. -* Unique deployment mode for Python applications. Compile a Python application on GraalPy to [a single native binary](Python-Standalone-Applications.md) that embeds all needed resources. -* Access to GraalVM's language ecosystems and tools. GraalPy can run many standard Python tools as well as tools from the GraalVM ecosystem. +## GraalPy Capabilities -### GraalPy Distributions - -GraalPy is available as **GraalPy built on Oracle GraalVM** and **GraalPy Community**. - -* GraalPy built on top of Oracle GraalVM provides the best experience: it comes with additional optimizations, is significantly faster and more memory-efficient. It is licensed under the [GraalVM Free Terms and Conditions (GFTC)](https://www.oracle.com/downloads/licenses/graal-free-license.html) license, same as Oracle GraalVM, which permits use by any user including commercial and production use. -Redistribution is permitted as long as it is not for a fee. - -* GraalPy Community is built on top of GraalVM Community Edition, and is fully open-source. - -Two language runtime options are available for the Oracle and Community distributions of GraalPy: - -* Native - * GraalPy is compiled ahead-of-time to a native executable. - * This means that you do not need a JVM to run GraalPy and it is compact in size. -* JVM - * You can easily exploit Java interoperability. - * Peak performance may be higher than the native option. - -### GraalPy Identification - -The four GraalPy runtimes are identified as follows, using the general pattern _graalpy(-community)(-jvm)-<version>-<os>-<arch>_: - - - - - - - - - - - - - - - - - -
 OracleCommunity
Nativegraalpy-<version>-<os>-<arch>graalpy-community-<version>-<os>-<arch>
JVMgraalpy-jvm-<version>-<os>-<arch>graalpy-community-jvm-<version>-<os>-<arch>
- - -### Comparison - -| Runtime | Native (default) | JVM | -|:-------|:-----------------|:----| -|Time to start | faster | slower | -| Time to reach peak performance | faster | slower | -| Peak performance (also considering GC) |good | best | -| Java interoperability | needs configuration | works | +See [GraalPy Capabilities](Standalone-Getting-Started.md#graalpy-capabilities). ## Installing GraalPy -> NOTE: There will be a delay between GraalPy release and its availability on Pyenv. - -### Linux - -The easiest way to install GraalPy on Linux is to use [Pyenv](https://github.com/pyenv/pyenv) (the Python version manager). -To install version 24.2.0 using Pyenv, run the following commands: -```bash -pyenv install graalpy-24.2.0 -``` -```bash -pyenv shell graalpy-24.2.0 -``` -> Before running `pyenv install`, you may need to update `pyenv` to include the latest GraalPy versions. - -Alternatively, you can download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases). - -1. Find the download that matches the pattern _graalpy-XX.Y.Z-linux-amd64.tar.gz_ or _graalpy-XX.Y.Z-linux-aarch64.tar.gz_ (depending on your platform) and download. -2. Uncompress the file and update your `PATH` environment variable to include to the _graalpy-XX.Y.Z-linux-amd64/bin_ (or _graalpy-XX.Y.Z-linux-aarch64/bin_) directory. - -### macOS - -The easiest way to install GraalPy on macOS is to use [Pyenv](https://github.com/pyenv/pyenv) (the Python version manager). -To install version 24.2.0 using Pyenv, run the following commands: -```bash -pyenv install graalpy-24.2.0 -``` -```bash -pyenv shell graalpy-24.2.0 -``` -> Before running `pyenv install`, you may need to update `pyenv` to include the latest GraalPy versions. - -Alternatively, you can download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases). - -1. Find the download that matches the pattern _graalpy-XX.Y.Z-macos-amd64.tar.gz_ or _graalpy-XX.Y.Z-macos-aarch64.tar.gz_ (depending on your platform) and download. -2. Remove the quarantine attribute. - ```bash - sudo xattr -r -d com.apple.quarantine /path/to/graalpy - ``` - For example: - ```bash - sudo xattr -r -d com.apple.quarantine ~/.pyenv/versions/graalpy-24.2.0 - ``` -3. Uncompress the file and update your `PATH` environment variable to include to the _graalpy-XX.Y.Z-macos-amd64/bin_ (or _graalpy-XX.Y.Z-macos-aarch64/bin_) directory. - -### Windows - -1. Find and download a compressed GraalPy installation file from [GitHub releases](https://github.com/oracle/graalpython/releases) that matches the pattern _graalpy-XX.Y.Z-windows-amd64.tar.gz_. -2. Uncompress the file and update your `PATH` variable to include to the _graalpy-XX.Y.Z-windows-amd64/bin_ directory. - -#### Windows Limitations - -The Windows distribution of GraalPy has more limitations than its Linux or macOS counterpart, so not all features and packages may be available. - -It has the following known issues: -- JLine treats Windows as a dumb terminal, with no autocomplete and limited editing capabilities in the REPL -- Interactive `help()` in the REPL doesn't work -- Inside a virtual environment: - - _graalpy.cmd_ and _graalpy.exe_ are broken - - _pip.exe_ cannot be used directly - - `pip` has trouble with cache file loading, use `--no-cache-dir` - - Only pure Python binary wheels can be installed, no native extensions or source builds - - To install a package, use `myvenv/Scripts/python.exe -m pip --no-cache-dir install ` -- Running from PowerShell works better than running from CMD, various scripts will fail on the latter +See [Installation](Standalone-Getting-Started.md#installation). ## Installing Packages -The best way of using GraalPy is from a [venv](https://docs.python.org/3/library/venv.html) virtual environment. -This generates wrapper scripts and makes the implementation usable from a shell as the standard Python interpreter. - -1. Create a virtual environment with GraalPy by running the following command: - ```bash - graalpy -m venv - ``` - For example: - ```bash - graalpy -m venv ~/.virtualenvs/graalpy-24.2.0 - ``` - -2. Activate the environment in your shell session: - ```bash - source /bin/activate - ``` - For example: - ```bash - source ~/.virtualenvs/graalpy-24.2.0/bin/activate - ``` - -Multiple executables are available in the virtual environment, including: `python`, `python3`, and `graalpy`. - -> Note: To deactivate the Python environment (and return to your shell), run `deactivate`. - -The `pip` package installer is available when using a virtual environment. -The GraalPy implementation of `pip` may choose package versions other than the latest in cases where it ships patches to make these work better. +See [Using Virtual Environments](Standalone-Getting-Started.md#using-virtual-environments). diff --git a/docs/user/Python-Standalone-Applications.md b/docs/user/Python-Standalone-Applications.md index fdbedb729b..3025ce734f 100644 --- a/docs/user/Python-Standalone-Applications.md +++ b/docs/user/Python-Standalone-Applications.md @@ -1,15 +1,19 @@ # Python Standalone Applications -GraalPy enables you to create a Python application or library as a native application or JAR file with no external dependencies. -The [Truffle framework](https://github.com/oracle/graal/tree/master/truffle) on which GraalPy is built virtualizes all filesystem accesses, including those to the standard library and installed pure Python packages. -Packages that include native code can still circumvent this, however! +GraalPy enables you to package your Python applications or libraries into native executables or JAR files with no external dependencies. +This means users can run your application without installing Python or any packages. -GraalPy includes a module named `standalone` to create a Python binary for Linux, macOS, and Windows. -The modules bundles all your application's resources into a single file. +GraalPy uses the [Truffle framework](https://github.com/oracle/graal/tree/master/truffle) to bundle your Python code, dependencies, and the Python runtime into standalone executables. +Truffle's filesystem virtualization allows everything to work from a single file, though packages with native C extensions may have limitations. -> Prerequisite: GraalPy distribution beginning with version 23.1.0. See [GraalPy releases](https://github.com/oracle/graalpython/releases). +GraalPy includes a module named `standalone` to create a Python binary for Linux, macOS, and Windows. +The module bundles all your application's resources into a single file. -For example, if you want to produce a native executable from a Python file named _my\_script.py_ along with packages you have installed in a virtual environment named _my\_venv_, run the following command: +> **Prerequisite:** GraalPy 23.1.0 or later. [Download here](https://github.com/oracle/graalpython/releases) or verify your version with `graalpy --version`. + +## Running Python Standalone Applications + +To create a native executable from a Python file with its dependencies, use this command: ```bash graalpy -m standalone native \ @@ -18,10 +22,16 @@ graalpy -m standalone native \ --venv my_env ``` -It produces a native _my_binary_ file which includes your Python code, the GraalPy runtime, and the Python standard library in a single, self-contained executable. +Where: + +* `--module my_script.py` states the main Python file that contains your application's entry point +* `--output my_binary` states the name for your standalone executable (no file extension needed) +* `--venv my_env` states the path to virtual environment with installed packages (you can omit this if there are no dependencies) + +This produces a native _my_binary_ file which includes your Python code, the GraalPy runtime, and the Python standard library in a single, self-contained executable. Use `graalpy -m standalone native --help` for further options. ### Security Considerations of Python Standalone Applications -Creating a native executable or a JAR file that includes Python code could be seen as a mild form of obfuscation, but it does not protect your source code. -Python source code is not stored verbatim into the executable (only the GraalPy bytecode is stored), but bytecode is easy to convert back into Python source code. +Standalone executables do not protect your source code. +Your Python code becomes bytecode, and bytecode can be easily decompiled back to readable Python code. diff --git a/docs/user/Python-on-JVM.md b/docs/user/Python-on-JVM.md index 3ee3be1e2c..8d40d17eba 100644 --- a/docs/user/Python-on-JVM.md +++ b/docs/user/Python-on-JVM.md @@ -1,28 +1,33 @@ -# Modern Python for the JVM +# Migrate from Jython to GraalPy -For Python version 2 (now EOL), Jython is the _de facto_ means of interfacing Python and Java. -Most existing Jython code that uses Java integration will be based on a stable Jython release—however, these are only available in Python 2.x versions. -GraalPy, in contrast, is compatible with Python 3.x and does not provide full compatibility with earlier 2.x versions of Jython. +Jython has been the standard way to run Python code on the JVM and integrate with Java libraries. +However, Jython's latest stable releases only support Python 2.x, which reached end-of-life (EOL) in 2020. -To migrate code from Python 2 to Python 3, follow [the official guide from the Python community](https://docs.python.org/3/howto/pyporting.html). -Once your Jython code is compatible with Python 3, follow this guide to iron out other differences between GraalPy and Jython. +GraalPy provides a modern alternative that supports Python 3.x on the JVM with excellent Java interoperability. +While GraalPy offers similar capabilities to Jython, there are important differences in how Java integration works. -GraalPy's first-class support for [Java interoperability](Interoperability.md) makes using Java libraries from Python as easy as possible, with special affordances for Java code beyond the generic interoperability support for other Graal languages (languages implemented on the [Truffle framework](https://www.graalvm.org/latest/graalvm-as-a-platform/language-implementation-framework/)). +This guide shows you how to migrate from Jython to GraalPy. -Not all features of Jython are supported on GraalPy. -Some are supported, but disabled by default due to their negative impact on runtime performance. -During migration, you can enable these features using a command line option: `--python.EmulateJython`. -We recommend to move away from these features, however, to achieve optimal performance. +### Prerequisites -## Migrating Jython Scripts +- To migrate Jython scripts to GraalPy, you first need to create a GraalPy embedding. For more information, see [Embedding Python in Java](Embedding-Getting-Started.md). +- Make sure to migrate code from Python 2 (as supported by Jython) to Python 3 (the major version GraalPy is compatible with) following [the official guide from the Python community](https://docs.python.org/3/howto/pyporting.html) -> To move plain Jython scripts from Jython to GraalPy, use a GraalPy JVM-based runtime. -> (For more information, see available [GraalPy Distributions](Python-Runtime.md)). +## GraalPy Java Interoperability Overview -### Importing a Java Package +GraalPy provides excellent [Java interoperability](Interoperability.md), allowing you to use Java libraries from Python with minimal friction. +It offers specialized features for Java integration that go beyond what's available for other languages on the GraalVM platform. -There are certain features of Jython's Java integration that are enabled by default on GraalPy. -Here is an example: +**Important:** GraalPy doesn't support all Jython features out of the box. +Some features are available but disabled by default for performance reasons. +You can enable them during migration with `--python.EmulateJython`, but updating your code to use GraalPy's native approach is recommended for better performance. + +## Java Package Imports + +### Packages That Work by Default + +Certain features of Jython's Java integration are enabled by default on GraalPy. +Here's what works the same: ```python >>> import java.awt as awt @@ -36,10 +41,12 @@ Here is an example: This example produces the same result when run on both Jython and GraalPy. However, when the example is run on GraalPy, only packages that are in the `java` namespace can be imported directly. -To import classes from packages outside the `java` namespace, use the `--python.EmulateJython` option. -> Note: When embedding GraalPy in a modularized application, you may have to -> add exports for the required modules according to JSR 376. +### Packages Outside the Java Namespace + +To import classes from packages outside the `java` namespace, use the `--python.EmulateJython` option during migration. + +> **Note:** When embedding GraalPy in a modularized application, you may have to add exports for the required modules according to JSR 376. Additionally, it is not possible to import Java packages as Python modules in all circumstances. For example, this will work: @@ -55,17 +62,18 @@ import javax.swing as swing from javax.swing import * ``` -Instead, import one of the classes directly: +Instead, import classes directly: ```python import javax.swing.Window as Window ``` -### Basic Object Usage +## Java Object Usage + +### Working with Java Objects -Constructing and working with Java objects and classes is achieved with conventional -Python syntax. -The methods of a Java object can also be retrieved and referenced as first class objects (bound to their instance), in the same way as Python methods. For example: +Constructing and working with Java objects and classes is achieved with conventional Python syntax. +The methods of a Java object can also be retrieved and referenced as first class objects (bound to their instance), in the same way as Python methods: ```python >>> from java.util import Random @@ -77,13 +85,15 @@ The methods of a Java object can also be retrieved and referenced as first class 1672896916 ``` -### Java-to-Python Types: Automatic Conversion +### Type Conversion -Method overloads are resolved by matching the Python arguments in a best-effort manner to the available parameter types. -This approach is also taken when converting data. -The goal here is to make using Java from Python as smooth as possible. -The matching approach taken by GraalPy is similar to Jython, but GraalPy uses a more dynamic approach to matching—Python types emulating `int` or `float` are also converted to the appropriate Java types. -This enables you, for example, to use a Pandas frame as `double[][]` or NumPy array elements as `int[]` when the elements fit into those Java primitive types. +GraalPy automatically converts between Python and Java types to make method calls and data passing seamless. +When you call Java methods, GraalPy matches your Python arguments to the available Java parameter types using a best-effort approach. + +GraalPy's type matching is more flexible than Jython's as it can convert any Python object with `__int__` or `__float__` methods to the corresponding Java types. +This means you can use NumPy arrays as Java `int[]` or Pandas DataFrames as Java `double[][]` when the data types are compatible. + +Here are the supported type conversions: | Java type | Python type | |:-------------------------------|:----------------------------------------------------------------------------------------| @@ -98,18 +108,19 @@ This enables you, for example, to use a Pandas frame as `double[][]` or NumPy ar | Java objects | Wrapped Java object of the appropriate type | | `java.lang.Object` | Any object | -### Special Jython Module: `jarray` +## Java Arrays + +### Special Jython Module: jarray GraalPy implements the `jarray` module (to create primitive Java arrays) for compatibility. -This module is always available, since we have not found its presence to have a negative impact. -For example: +This module is always available, since we have not found its presence to have a negative impact: ```python >>> import jarray >>> jarray.array([1,2,3], 'i') ``` -Note that its usage is equivalent to constructing the array type using the `java.type` function and then populating the array, as follows: +Note that its usage is equivalent to constructing the array type using the `java.type` function and then populating the array: ```python >>> import java @@ -133,10 +144,9 @@ However, implicitly, this may produce a copy of the array data, which can be dec [98, 97, 122] ``` -### Exceptions from Java +## Java Exceptions -You can catch Java exceptions as you would expect. -For example: +You can catch Java exceptions as you would expect: ```python >>> import java @@ -149,105 +159,116 @@ For example: 7 >= 0 ``` -### Java Collections +## Java Collections + +### Collection Interface Features -* Java arrays and collections that implement the `java.util.Collection` interface can be accessed using the `[]` syntax. +Java arrays and collections that implement the `java.util.Collection` interface can be accessed using the `[]` syntax. An empty collection is considered `false` in boolean conversions. -The length of a collection is exposed by the `len` built-in function. -For example: +The length of a collection is exposed by the `len` built-in function: - ```python - >>> from java.util import ArrayList - >>> l = ArrayList() - >>> l.add("foo") - True - >>> l.add("baz") - True - >>> l[0] - 'foo' - >>> l[1] = "bar" - >>> del l[1] - >>> len(l) - 1 - >>> bool(l) - True - >>> del l[0] - >>> bool(l) - False - ``` - -* Java iterables that implement the `java.lang.Iterable` interface can be iterated over using a `for` loop or the `iter` built-in function and are accepted by all built-ins that expect an iterable. -For example: +```python +>>> from java.util import ArrayList +>>> l = ArrayList() +>>> l.add("foo") +True +>>> l.add("baz") +True +>>> l[0] +'foo' +>>> l[1] = "bar" +>>> del l[1] +>>> len(l) +1 +>>> bool(l) +True +>>> del l[0] +>>> bool(l) +False +``` - ```python - >>> [x for x in l] - ['foo', 'bar'] - >>> i = iter(l) - >>> next(i) - 'foo' - >>> next(i) - 'bar' - >>> next(i) - Traceback (most recent call last): - File "", line 1, in - StopIteration - >>> set(l) - {'foo', 'bar'} - ``` - -* An iterator can be iterated as well. For example: - - ```python - >>> from java.util import ArrayList - >>> l = ArrayList() - >>> l.add("foo") - True - >>> i = l.iterator() # Calls the Java iterator methods - >>> next(i) - 'foo' - ``` - -* Mapped collections that implement the `java.util.Map` interface can be accessed using the `[]` notation. -An empty map is considered `false` in boolean conversions. Iteration of a map yields its keys, consistent with `dict`. -For example: +### Iterating Over Collections + +Java iterables that implement the `java.lang.Iterable` interface can be iterated over using a `for` loop or the `iter` built-in function and are accepted by all built-ins that expect an iterable: + +```python +>>> [x for x in l] +['foo', 'bar'] +>>> i = iter(l) +>>> next(i) +'foo' +>>> next(i) +'bar' +>>> next(i) +Traceback (most recent call last): +File "", line 1, in +StopIteration +>>> set(l) +{'foo', 'bar'} +``` + +You can also iterate over Java iterators directly: + +```python +>>> from java.util import ArrayList +>>> l = ArrayList() +>>> l.add("foo") +True +>>> i = l.iterator() # Calls the Java iterator methods +>>> next(i) +'foo' +``` + +### Working with Maps + +Mapped collections that implement the `java.util.Map` interface can be accessed using the `[]` notation. +An empty map is considered `false` in boolean conversions. +Iteration of a map yields its keys, consistent with `dict`: + +```python +>>> from java.util import HashMap +>>> m = HashMap() +>>> m['foo'] = 5 +>>> m['foo'] +5 +>>> m['bar'] +Traceback (most recent call last): +File "", line 1, in +KeyError: bar +>>> [k for k in m] +['foo'] +>>> bool(m) +True +>>> del m['foo'] +>>> bool(m) +False +``` - ```python - >>> from java.util import HashMap - >>> m = HashMap() - >>> m['foo'] = 5 - >>> m['foo'] - 5 - >>> m['bar'] - Traceback (most recent call last): - File "", line 1, in - KeyError: bar - >>> [k for k in m] - ['foo'] - >>> bool(m) - True - >>> del m['foo'] - >>> bool(m) - False - ``` - -### Inheritance from Java +## Inheritance from Java Classes + +### Understanding Java Class Inheritance Inheriting from a Java class (or implementing a Java interface) is supported with some syntactical and significant behavioral differences from Jython. To create a class that inherits from a Java class (or implements a Java interface), use the conventional Python `class` statement. Declared methods override (implement) superclass (interface) methods when their names match. -It is important to understand that there is actually delegation happening here - when inheriting from Java, two classes are created, one in Java and one in Python. +**Important:** There is actually delegation happening here - when inheriting from Java, two classes are created, one in Java and one in Python. These reference each other and any methods that are declared in Python that override or implement a Java method on the superclass are declared on the Java side as delegating to Python. The created object does not behave like a Python object but instead in the same way as a foreign Java object. The reason for this is that when you create an instance of your new class, you get a reference to the *Java* object. -To call Python methods that do *not* override or implement methods that already existed on the superclass, you need to use the special `this` attribute. -Once you are in a Python method, your `self` refers to the Python object, and to get back from a Python method to Java, use the special attribute `__super__`. -And since we do not expose static members on the instance side, if you need to call a static method from an instance on the Java side, use `getClass().static` to get to the meta-object holding the static members. +### Inheritance behavior up to GraalPy version 25.1 + +When inheriting from a Java class, you can pass the keyword `new_style=False`. +This is the default up to and including GraalPy version 25.1. + +Key points for legacy inheritance: -One important consequence of the two-object-schema here is that the `__init__` method on the Python object is actually called *before* the connection to the Java side is established. -So you cannot currently override construction of the Java object or run code during initialization that would affect the Java half of the combined structure. -You will have to create a factory method if you want to achieve this. +- The generated class is a Java object and no forwarding to the Python-side happens by default +- To call Python methods that do *not* override or implement methods that already existed on the superclass, you need to use the special `this` attribute +- Once you are in a Python method, your `self` refers to the Python object, and to get back from a Python method to Java, use the special attribute `__super__` +- If you need to call a static method from an instance on the Java side, use `getClass().static` to get to the meta-object holding the static members +- The `__init__` method on the Python object is actually called *before* the connection to the Java side is established, so you cannot currently override construction of the Java object For example: @@ -255,7 +276,6 @@ For example: import atexit from java.util.logging import Logger, Handler - class MyHandler(Handler): def __init__(self): self.logged = [] @@ -263,7 +283,6 @@ class MyHandler(Handler): def publish(self, record): self.logged.append(record) - logger = Logger.getLogger("mylog") logger.setUseParentHandlers(False) handler = MyHandler() @@ -281,18 +300,66 @@ for record in handler.this.logged: For more information about how the generated Java subclass behaves, see the [Truffle documentation](https://www.graalvm.org/truffle/javadoc/com/oracle/truffle/api/TruffleLanguage.Env.html#createHostAdapter(java.lang.Object%5B%5D)). +### Inheritance behavior from GraalPy 25.1 + +When inheriting from a Java class, you can pass the keyword `new_style=True`. This is the default after GraalPy version 25.1. +The generated class is a Java object, but attribute lookup is dispatched to the Python object as needed. + +Features of modern inheritance: + +- Multiple levels of inheritance are supported +- `super()` calls work both in the constructor override via `__new__` as well as in Java method overrides +- The `self` in a method refers to the Java object, but any access that does not refer to a field or method on the Java class is transparently dispatched to the Python side +- Static methods can be called both from the instance as well as the class + +For example: + +```python +from java.util.logging import Level + +class PythonLevel(Level, new_style=True): + def __new__(cls, name="default name", level=2): + """Provide a default constructor that modifies + the construction of the Java instance""" + return super().__new__(cls, name, level) + + def __init__(self, *args, **kwarg): + """After the instance is created, initialize the + misc_value field""" + self.misc_value = 42 + + def getName(self): + """This overrides the Java method on + java.util.logging.Level""" + return super().getName() + " from Python with super()" + + def pythonName(self): + """This adds a method that is only visible from Python, + but self and super calls work as expected""" + return f"PythonName for Level {self.intValue()} named {super().getName()}" + + def callStaticFromPython(self, name): + """Java static methods can be called from the + instance as well as the class""" + return self.parse(name) + +pl = PythonLevel() +assert issubclass(PythonLevel, Level) +assert PythonLevel.parse("INFO").getName() == "INFO" +``` + ## Embedding Python into Java -The other way to use Jython was to embed it into a Java application. There were two options for such an embedding. +If you were embedding Jython in Java applications, there were two main approaches that need different migration paths: + +- **`PythonInterpreter` approach:** Use the `PythonInterpreter` object that Jython provides. + + Existing code using Jython in this manner depends directly on the Jython package (for example, in the Maven configuration), because the Java code has references to Jython internal classes. These classes do not exist in GraalVM, and no equivalent classes are exposed. + + Switch to the [GraalVM SDK](https://central.sonatype.com/artifact/org.graalvm.sdk/graal-sdk). Using this SDK, no APIs particular to Python are exposed, everything is achieved via the GraalVM API, with maximum configurability of the Python runtime. Refer to the [Embedding Getting Started](Embedding-Getting-Started.md) documentation for preparing a setup. + +- **JSR 223 `ScriptEngine` approach:** Embed Jython in Java via [JSR 223](https://www.jcp.org/en/jsr/detail?id=223) by using the classes of the `javax.script` package, and, in particular, via the `ScriptEngine` class. -1. Use the `PythonInterpreter` object that Jython provides. -Existing code using Jython in this manner depends directly on the Jython package (for example, in the Maven configuration), because the Java code has references to Jython internal classes. -These classes do not exist in GraalVM, and no equivalent classes are exposed. -To migrate from this usage, switch to the [GraalVM SDK](https://central.sonatype.com/artifact/org.graalvm.sdk/graal-sdk). -Using this SDK, no APIs particular to Python are exposed, everything is achieved via the GraalVM API, with maximum configurability of the Python runtime. -Refer to the [Getting Started](README.md) documentation for preparing a setup. + This approach is not recommended, because the `ScriptEngine` APIs are not a clean fit for the options and capabilities of GraalPy. -2. Embed Jython in Java via [JSR 223](https://www.jcp.org/en/jsr/detail?id=223) by using the classes of the the `javax.script` package, and, in particular, via the `ScriptEngine` class. -We do not recommend this approach, because the `ScriptEngine` APIs are not a clean fit for the options and capabilities of GraalPy. -However, to migrate existing code, we provide an example ScriptEngine implementation that you can inline into your project. -Refer to [the reference manual for embedding](https://www.graalvm.org/latest/reference-manual/embed-languages/#compatibility-with-jsr-223-scriptengine) for details. + However, to migrate existing code, an example ScriptEngine implementation is provided that you can inline into your project. Refer to [the Embedding Languages reference manual](https://www.graalvm.org/latest/reference-manual/embed-languages/#compatibility-with-jsr-223-scriptengine) for details. diff --git a/docs/user/README.md b/docs/user/README.md index 43886c14b4..f28d486032 100644 --- a/docs/user/README.md +++ b/docs/user/README.md @@ -1,210 +1,65 @@ -# Getting Started with GraalPy on the JVM - -You can use GraalPy with GraalVM JDK, Oracle JDK, or OpenJDK. -You can easily add GraalPy to your Java application using Maven or Gradle build tools as shown below. -Other build systems (Ant, Make, CMake, and so on) can also be used with a bit more manual work. - -## Maven - -GraalPy can generate a Maven project that embeds Python packages into a Java application using [Maven artefacts](https://central.sonatype.com/namespace/org.graalvm.python). - -1. GraalPy project publishes a Maven archetype to generate a starter project: - ```bash - mvn archetype:generate \ - -DarchetypeGroupId=org.graalvm.python \ - -DarchetypeArtifactId=graalpy-archetype-polyglot-app \ - -DarchetypeVersion=24.2.0 - ``` - -2. Build a native executable using the [GraalVM Native Image "tool"](https://www.graalvm.org/latest/reference-manual/native-image/) plugin that was added for you automatically: - ```bash - mvn -Pnative package - ``` - -3. Once completed, run the executable: - ```bash - ./target/polyglot_app - ``` - The application prints "hello java" to the console. - -The project uses the [GraalVM Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) with additional features to manage Python virtual environments and integrate Python package dependencies with a Maven workflow. -The Java code and the _pom.xml_ file are heavily documented and the generated code describes available features. - -See also [Embedding Build Tools](Embedding-Build-Tools.md#graalpy-maven-plugin) for more information about the GraalPy Maven Plugin. - -### Creating Cross-platform JARs with Native Python Packages - -The generated project uses the GraalPy Maven plugin, which makes it easy to add Python dependencies. -However, Python packages may have native components that are specific to the build system. -In order to distribute the resulting application for other systems, follow these steps: - -1. Build the project on each deployment platform. - Rename JAR files so they each have a platform-specific name and move them to a temporary directory on the same machine. - -2. Unzip each of the JAR files (substituting the correct names for the JAR files). - A special file, _vfs/fileslist.txt_ needs to be concatenated from each JAR file. - Finally, create a new _combined.jar_ from the combination of all files and with the concatenated _fileslist.txt_. - ```bash - unzip linux.jar -d combined - mv combined/vfs/fileslist.txt fileslist-linux.txt - unzip windows.jar -d combined - mv combined/vfs/fileslist.txt fileslist-windows.txt - cat fileslist-linux.txt fileslist-windows.txt > combined/vfs/fileslist.txt - cd combined - zip -r ../combined.jar * - ``` - -## Gradle - -1. Create a Java application with Gradle using the command below and follow the prompts (select the Groovy build script language, select a test framework, and so on): - ```bash - gradle init --type java-application \ - --project-name interop \ - --package interop \ - --no-split-project - ``` - - The project is generated in the current working directory with the following structure: - ```bash - └── app - ├── build.gradle - └── src - └── main - ├── java - │ └── interop - │ └── App.java - └── resources - ``` - -2. Open your project configuration file, _app/build.gradle_, and modify it as follows. - - Include the GraalPy support and the [GraalVM Polyglot API](https://www.graalvm.org/sdk/javadoc/org/graalvm/polyglot/package-summary.html) in the `dependencies` section: - ```bash - implementation("org.graalvm.polyglot:polyglot:24.2.0") - implementation("org.graalvm.polyglot:python:24.2.0") - ``` - -3. Finally, replace the code in the file named _App.java_ as follows for a small Python embedding: - ```java - package interop; - - import org.graalvm.polyglot.*; - - class App { - public static void main(String[] args) { - try (var context = Context.create()) { - System.out.println(context.eval("python", "'Hello Python!'").asString()); - } - } - } - ``` - -4. Run the application with Gradle: - ```bash - ./gradlew run - ``` - The application prints "Hello Python!" to the console. - - > Note: The performance of the GraalPy runtime depends on the JDK in which you embed it. For more information, see [Runtime Optimization Support](https://www.graalvm.org/latest/reference-manual/embed-languages/#runtime-optimization-support). - -5. Optionally, you can also use a third-party Python package. - - 5.1. In _app/build.gradle_: - - add the graalpy-gradle-plugin to the `plugins` section: - ```bash - id "org.graalvm.python" version "24.2.0" - ``` - - - configure the GraalPy Gradle plugin: - ```bash - graalPy { - packages = ["termcolor==2.2"] - } - ``` - - 5.2. In _settings.gradle_, add the following `pluginManagement` configuration. - ```bash - pluginManagement { - repositories { - gradlePluginPortal() - } - } - ``` - - 5.3. Update the file named _App.java_ as follows: - ```java - package interop; - - import org.graalvm.polyglot.*; - import org.graalvm.python.embedding.GraalPyResources; - - class App { - ... - public static void main(String[] args) { - try (Context context = GraalPyResources.createContext()) { - String src = """ - from termcolor import colored - colored_text = colored("hello java", "red", attrs=["reverse", "blink"]) - print(colored_text) - """; - context.eval("python", src); - } - } - ``` - -See also [Embedding Build Tools](Embedding-Build-Tools.md) for more information about the GraalPy Gradle Plugin. - -## Ant, CMake, Makefile or Other Build Systems Without Direct Support for Maven Dependencies - -Some (often older) projects may be using Ant, Makefiles, CMake, or other build systems that do not directly support Maven dependencies. -Projects such as [Apache Ivy™](https://ant.apache.org/ivy/history/master/tutorial/start.html) enable such build systems to resolve Maven dependencies, but developers may have reasons not to use them. -GraalPy comes with a tool to obtain the required JAR files from Maven. - -1. Assuming there is some directory where third-party dependencies are stored for the project and that the build system is set up to put any JAR files there on the classpath, the project directory tree might look similar to this: - - ```bash - ├───lib - │ └─── ... *.jar dependencies are here - └───src - └─── ... *.java files and resources are here - ``` - -2. [Install GraalPy](Python-Runtime.md#installing-graalpy) for your system and ensure you have `graalpy` on your `PATH`. - Open a command-line interface and enter your project directory. - Then, as appropriate for your system, run one of the following commands: - - In a POSIX shell: - ```bash - export GRAALPY_HOME=$(graalpy -c 'print(__graalpython__.home)') - "${GRAALPY_HOME}/libexec/graalpy-polyglot-get" -a python -o lib -v "24.2.0" - ``` - - In PowerShell: - ```bash - $GRAALPY_HOME = graalpy -c "print(__graalpython__.home)" - & "$GRAALPY_HOME/libexec/graalpy-polyglot-get" -a python -o lib -v "24.2.0" - ``` - - These commands download all GraalPy dependencies into the _lib_ directory. - -3. Provided that your build system is set up to pick up the JAR files from _lib_, the GraalPy embedding code below should work if put in an appropriate place in the project to run as the main class. - - ```java - import org.graalvm.polyglot.*; - - public class Hello { - public static void main(String[] args) { - try (var context = Context.newBuilder().option("engine.WarnInterpreterOnly", "false").build()) { - System.out.println(context.eval("python", "'Hello Python!'").asString()); - } - } - } - ``` - -## Testing Python Applications and Packages on GraalPy - -Go [here](Python-Runtime.md) to get a CPython compatible distribution of GraalPy to test Python applications and packages. - -#### Related Documentation - -- [Modern Python on the JVM](Python-on-JVM.md) -- [Embedding Graal languages in Java](https://www.graalvm.org/latest/reference-manual/embed-languages/) +# GraalPy User Guide + +GraalPy is a Python 3.12 compliant runtime that provides better performance, native compilation capabilities, and seamless Java interoperability. + +Here are the two main types of users and how they can benefit from GraalPy: + +**For JVM developers** who need Python libraries in their applications or have legacy Jython code, GraalPy can be embedded directly into JVM projects using Maven or Gradle, see the [Embed Python in Java](#embedding-python-in-java) section. + +**For Python developers** who want better performance and native compilation, GraalPy serves as a drop-in replacement for standard Python, see the [GraalPy as CPython Alternative](#using-graalpy-as-a-standalone-python-runtime) section. + +## Embedding Python in Java + +**For JVM developers who need to use Python libraries from their JVM applications or migrate from legacy Jython code.** + +You do not need to install GraalPy separately - you can use GraalPy directly in Java with Maven or Gradle. +This lets you call Python libraries like NumPy, pandas, or any PyPI package from your Java application. +GraalPy also provides a migration path from Jython 2.x to Python 3.x with better performance and maintained Java integration capabilities. + +These guides cover everything you need to know: + +- **[Getting Started](Embedding-Getting-Started.md)** - Maven and Gradle setup +- **[Build Tools](Embedding-Build-Tools.md)** - Detailed plugin documentation +- **[Permissions](Embedding-Permissions.md)** - Configure security settings +- **[Interoperability](Interoperability.md)** - Java and Python integration patterns +- **[Native Images](Native-Images-with-Python.md)** - Compile to native executables +- **[Migration Guide](Python-on-JVM.md)** - Complete Jython to GraalPy migration + +## Using GraalPy as a Standalone Python Runtime + +**You want to use GraalPy instead of the standard Python from python.org.** + +Install GraalPy on your machine and use it like any Python interpreter. +You get better performance, the ability to compile to native binaries, and access to the GraalVM ecosystem. + +These guides cover everything you need to know: + +- **[Getting Started](Standalone-Getting-Started.md)** - Installation and basic usage +- **[Standalone Applications](Python-Standalone-Applications.md)** - Compile Python to native binaries +- **[Native Extensions](Native-Extensions.md)** - Working with C extensions and native packages +- **[Interoperability](Interoperability.md)** - Use Java and other Graal languages from Python +- **[Performance](Performance.md)** - Optimization tips and benchmarks +- **[Tooling](Tooling.md)** - IDE integration and development tools + +## General Information + +- **[Test Tiers](Test-Tiers.md)** - Platform compatibility and testing information +- **[Troubleshooting](Troubleshooting.md)** - Common embedding issues and solutions + +## Version Compatibility + +The following table shows which Python versions are supported by each GraalPy release: + +| GraalPy Version | Python Version | GraalVM Platform | +| --------------- | -------------- | --------------------------------------------------------------- | +| 25.x | Python 3.12.8 | Oracle GraalVM 25.x, GraalVM Community Edition 25.x | +| 23.x | Python 3.10.8 | Oracle GraalVM for JDK 21.x, Oracle GraalVM for JDK 17.x | +| 22.x | Python 3.8.5 | GraalVM Enterprise Edition 21.3.x | + +### Platform Support + +GraalPy is mostly written in Java and Python, but the Python package ecosystem is rich in native packages that need platform specific support via native libraries that expose platform-specific APIs. +The main operating system is Oracle Linux, the CPU architectures are AMD64 and ARM, and the primary JDK is Oracle GraalVM. +**Linux is recommended for getting started with GraalPy.** Windows and macOS with GraalVM JDK are less well tested, and outside of those combinations only basic test coverage is provided. +As macOS and other platforms are not prioritized, some GraalPy features may not work on these platforms. +See [Test Tiers](Test-Tiers.md) for a detailed breakdown. diff --git a/docs/user/Standalone-Getting-Started.md b/docs/user/Standalone-Getting-Started.md new file mode 100644 index 0000000000..20a5f320f1 --- /dev/null +++ b/docs/user/Standalone-Getting-Started.md @@ -0,0 +1,196 @@ +# Using GraalPy as a Standalone Python Runtime + +GraalPy can be used as a standalone Python runtime, providing a drop-in replacement for CPython. +This guide covers choosing a distribution, installation, package management, basic usage, and deployment options for standalone GraalPy applications. + +## Choosing a GraalPy Distribution + +GraalPy is available in multiple distributions: + +### Distribution Options + +- **GraalPy built on Oracle GraalVM** provides the best experience with additional optimizations, significantly faster performance, and better memory efficiency. It is licensed under the [GraalVM Free Terms and Conditions (GFTC)](https://www.oracle.com/downloads/licenses/graal-free-license.html), which permits use by any user including commercial and production use. Redistribution is permitted as long as it is not for a fee. +- **GraalPy Community** is built on top of GraalVM Community Edition and is fully open source. + +### Runtime + +The standalone GraalPy runtime is compiled ahead-of-time to a native executable. +You do not need a JVM to run it, and it has a compact size, fast startup, and fast time to reach peak performance. +For Java interoperability and JVM application embedding, see [Embedding Python in Java](Embedding-Getting-Started.md). + +### Distribution Identification + +The GraalPy standalone runtimes are identified using the pattern _graalpy(-community)<python-version>-<graal-version>-<os>-<arch>_: + +| Distribution | Runtime | License | +|---------------|-----------------------------------------------------------------|---------------------------------------------------------------------------| +| **Oracle** | `graalpy---` | [GFTC](https://www.oracle.com/downloads/licenses/graal-free-license.html) | +| **Community** | `graalpy-community---` | [UPL](https://opensource.org/licenses/UPL) | + +## GraalPy Capabilities + +GraalPy provides a Python 3.12 compliant runtime. +A primary goal is to support PyTorch, SciPy, and their constituent libraries, as well as to work with other data science and machine learning libraries from the rich Python ecosystem. + +GraalPy provides the following capabilities: + +- CPython-compatible distribution for testing Python code on GraalPy. +- A [single native binary packaging mode](Python-Standalone-Applications.md) for Python applications. +- Access to GraalVM language ecosystems and tools. + +## Installation + +> **Note**: There may be a delay between GraalPy release and its availability on Pyenv. + +### Linux (Recommended Platform) + +The easiest way to install GraalPy on Linux is to use [Pyenv](https://github.com/pyenv/pyenv) (the Python version manager): + +```bash +# Update pyenv to include latest GraalPy versions (if needed) +pyenv update + +# Install GraalPy 25.0.3 +pyenv install graalpy-25.0.3 + +# Use GraalPy for the current shell session +pyenv shell graalpy-25.0.3 +``` + +#### Manual Installation (Linux) + +1. Download the appropriate binary from [GitHub releases](https://github.com/oracle/graalpython/releases): + + - AMD64: `graalpy3.12-25.1.0-linux-amd64.tar.gz` + - ARM64: `graalpy3.12-25.1.0-linux-aarch64.tar.gz` + +2. Extract and add it to your `PATH` environment variable: + + ```bash + tar -xzf graalpy3.12-25.1.0-linux-amd64.tar.gz + export PATH="$PWD/graalpy3.12-25.1.0-linux-amd64/bin:$PATH" + ``` + +### macOS + +Using Pyenv (recommended): + +```bash +# Install GraalPy 25.0.3 +pyenv install graalpy-25.0.3 + +# Use GraalPy for the current shell session +pyenv shell graalpy-25.0.3 +``` + +#### Manual Installation (macOS) + +1. Download the binary from [GitHub releases](https://github.com/oracle/graalpython/releases). + +2. Remove quarantine attribute: + + ```bash + sudo xattr -r -d com.apple.quarantine /path/to/graalpy + # For example: + sudo xattr -r -d com.apple.quarantine ~/.pyenv/versions/graalpy-25.0.3 + ``` + +3. Extract and add it to your `PATH` environment variable: + + ```bash + tar -xzf graalpy3.12-25.1.0-macos-aarch64.tar.gz + export PATH="$PWD/graalpy3.12-25.1.0-macos-aarch64/bin:$PATH" + ``` + +### Windows + +> **Warning**: The Windows distribution has more limitations than Linux or macOS. Not all features and packages may be available. + +1. Download the binary from [GitHub releases](https://github.com/oracle/graalpython/releases). + +2. Extract and add it to your `PATH` environment variable: + + ```powershell + # Extract the file and update your PATH environment variable + # to include the graalpy3.12-25.1.0-windows-amd64/bin directory + tar -xzf graalpy3.12-25.1.0-windows-amd64.zip + $env:PATH = "$PWD\graalpy3.12-25.1.0-windows-amd64\bin;$env:PATH" + ``` + +#### Known Windows Limitations + +- JLine treats Windows as a dumb terminal (no autocomplete, limited REPL editing) +- Interactive `help()` in REPL doesn't work +- Virtual environment issues: + - `graalpy.cmd` and `graalpy.exe` are broken inside `venv` + - `pip.exe` cannot be used directly + - Use `myvenv/Scripts/python.exe -m pip --no-cache-dir install ` + - Only pure Python binary wheels supported +- PowerShell works better than CMD + +## Using Virtual Environments + +The recommended way to use GraalPy is with [venv](https://docs.python.org/3/library/venv.html) virtual environments: + +### Creating a Virtual Environment + +```bash +# Create a virtual environment +graalpy -m venv ~/.virtualenvs/graalpy-25.0.3 + +# Activate the environment +source ~/.virtualenvs/graalpy-25.0.3/bin/activate +``` + +### Installing Packages + +Once in a virtual environment, you can use `pip` to install packages: + +```bash +# Install a package +pip install requests + +# Install with requirements file +pip install -r requirements.txt +``` + +> **Note**: GraalPy's `pip` implementation may choose different package versions to ensure better compatibility. + +To deactivate the virtual environment: + +```bash +# Return to your normal shell environment +deactivate +``` + +## Running Python Code + +Once installed, you can use GraalPy like any other Python interpreter: + +```bash +# Interactive REPL +graalpy + +# Run a Python script +graalpy myscript.py + +# Run a module +graalpy -m mymodule + +# Execute inline code +graalpy -c "print('Hello from GraalPy!')" +``` + +## Platform Support + +**Linux is the recommended platform** for GraalPy. +The main testing focus is: + +- **Operating System**: Oracle Linux +- **CPU Architectures**: AMD64 and ARM64 +- **Primary JDK**: Oracle GraalVM + +Windows and macOS with GraalVM JDK have less comprehensive testing. +Some GraalPy features may not work optimally on these platforms. + +See [Test Tiers](Test-Tiers.md) for a detailed breakdown of platform support. diff --git a/docs/user/Test-Tiers.md b/docs/user/Test-Tiers.md new file mode 100644 index 0000000000..eb1dfedc05 --- /dev/null +++ b/docs/user/Test-Tiers.md @@ -0,0 +1,61 @@ +# Detailed Test Tier Breakdown + +GraalPy organizes platform testing into tiers that indicate the level of testing rigor and support you can expect for different platform configurations. This tiering system helps you understand: + +- How thoroughly your platform is tested +- What level of stability to expect +- Which features are fully supported vs. experimental + +Platforms are identified using the target tuple format: `[CPU architecture]-[Operating System]-[libc]-[JDK]-[Java version]`. JDK names follow [SDKMAN!](https://sdkman.io/) conventions, and "graal" refers to both Oracle GraalVM and GraalVM Community Edition (including Native Image). + +> **Important:** GraalPy test tiers are similar to [CPython Platform Support Tiers](https://peps.python.org/pep-0011/), but do not constitute or imply any commitment to support. + +Pure Python code runs reliably on GraalPy with recent JDKs when JIT compilation is disabled. However, advanced features like native extensions, platform-specific APIs, and JIT compilation have varying support depending on your platform tier. + +### Tier 1 + +- **Stability:** CI failures block releases. Changes which would break the main or release branches are not allowed to be merged; any breakage should be fixed or reverted immediately. +- **Responsibility:** All core developers are responsible to keep main, and thus these platforms, working. +- **Coverage:** Platform-specific Python APIs and Python C extensions are fully tested. + +| Platform | Notes | +|----------------------------------|----------------------------| +| amd64-linux-glibc-graal-latest | Oracle Linux 8 or similar. | +| aarch64-linux-glibc-graal-latest | Oracle Linux 8 or similar. | + +### Tier 2 + +- **Stability:** CI failures block releases. Changes which would break the main or release branches are not allowed to be merged; any breakage should be fixed or tests marked as skipped. +- **Test Coverage:** Circa 10% of tests running on Tier 1 platforms may be skipped on Tier 2 platforms. +- **Feature Support:** Platform-specific Python APIs are fully tested; Python C extensions may have more issues than on Tier 1 platforms. + +| Platform | Notes | +|-----------------------------------|-------------------------| +| aarch64-macos-darwin-graal-latest | macOS on M-series CPUs. | + +### Tier 3 + +- **Stability:** CI failures block releases. Changes which would break the main or release branches are not allowed to be merged; any breakage should be fixed or tests marked as skipped. +- **Test Coverage:** Circa 25% of tests running on Tier 1 platforms may be skipped on Tier 3. +- **Feature Support:** Tests for platform-specific Python APIs and Python C extension are run, but not prioritized. + +| Platform | Notes | +|---------------------------------|----------------------------------------------| +| amd64-windows-msvc-graal-latest | Windows 11, Windows Server 2025, or newer. | +| amd64-linux-glibc-oracle-21 | JDK 21 is tested without JIT compilation. | +| aarch64-linux-glibc-oracle-21 | JDK 21 is tested without JIT compilation. | +| aarch64-macos-darwin-oracle-21 | JDK 21 is tested without JIT compilation. | +| amd64-macos-darwin-oracle-21 | JDK 21 is tested without JIT compilation. | +| amd64-windows-msvc-oracle-21 | JDK 21 is tested without JIT compilation. | + +### Tier 4 + +- **Stability:** CI failures do not block releases. Tests may be broken on the main and release branches. +- **Test Coverage:** Smoke tests with platform-agnostic pure Python workloads are run on a regular schedule. +- **Feature Support:** Only basic pure Python functionality is tested; platform-specific features and extensions are not prioritized. + +| Platform | Notes | +| ------------------------------- | ----------------------------------------------| +| amd64-linux-musl-graal-latest | Ensures GraalPy can be built for and used on musl libc platforms such as Alpine Linux. | +| amd64-linux-glibc-j9-17 | Ensures that non-Oracle JVMs work for pure Python code without JIT. | +| ppc64le-linux-glibc-oracle-17 | Ensures that other architectures (ppc64le, s390x, risc-v) work for pure Python code without JIT. | diff --git a/docs/user/Tooling.md b/docs/user/Tooling.md index 1861ba588a..e0754c2af2 100644 --- a/docs/user/Tooling.md +++ b/docs/user/Tooling.md @@ -11,30 +11,42 @@ To enable the debugger, pass the `--inspect` command-line option. You can inspect variables, set watch expressions, interactively evaluate code snippets, and so on. 1. Run a Python script using the command-line option `--inspect`: + ```bash graalpy --inspect my_script.py - ``` + ``` 2. You should see output similar to: + ```bash Debugger listening on ws://127.0.0.1:9229/VrhCaY7wR5tIqy2zLsdFr3f7ixY3QB6kVQ0S54_SOMo For help, see: https://www.graalvm.org/tools/chrome-debugger E.g. in Chrome open: devtools://devtools/bundled/js_app.html?ws=127.0.0.1:9229/VrhCaY7wR5tIqy2zLsdFr3f7ixY3QB6kVQ0S54_SOMo ``` -3. Open your Chrome browser and enter the URL provided. -Now you can inspect the stack, variables, evaluate variables, and selected expressions in a tooltip, and so on. For example: +3. Open Chrome browser and enter the provided URL. + + You can now: + - Inspect the call stack and variables + - Set breakpoints and step through code + - Evaluate expressions in the console + - View variable values in tooltips + + For example: ![Chrome Inspector](./assets/Chrome_Inspector.png) ## Profiling -GraalPy provides three main profiling capabilities: a CPU sampler, a CPU tracer, and a memory tracer. -These are described below. (For details, use the `graalpy --help:tools` command.) +GraalPy provides three main profiling capabilities: CPU sampling, CPU tracing, and memory tracing. +Each tool is described below. + +For complete options, use: `graalpy --help:tools` -## CPU Sampler +### CPU Sampler -Use the `--cpusampler` command-line option to take a CPU sample. For example: +Use the `--cpusampler` command-line option to take a CPU sample. +For example: ```bash graalpy --cpusampler my_script.py ``` @@ -42,7 +54,9 @@ graalpy --cpusampler my_script.py You should see output similar to: {::options parse_block_html="true" /} -
CPU Sampler Output (Click to expand) +
+ CPU Sampler Output (Click to expand) + ```bash -------------------------------------------------------------------------------------------------------------------------------------------------------------- Sampling Histogram. Recorded 564 samples with period 10ms. Missed 235 samples. @@ -61,12 +75,15 @@ Thread[main,5,main] ... -------------------------------------------------------------------------------------------------------------------------------------------------------------- ``` +
{::options parse_block_html="false" /} -## CPU Tracer +### CPU Tracer + +Use the `--cputracer --cputracer.TraceStatements` command-line options to trace CPU usage. +For example: -Use the `--cputracer --cputracer.TraceStatements` command-line options to trace CPU usage. For example: ```bash graalpy --cputracer --cputracer.TraceStatements my_script.py ``` @@ -74,7 +91,9 @@ graalpy --cputracer --cputracer.TraceStatements my_script.py You should see output similar to: {::options parse_block_html="true" /} -
CPU Tracer Output (Click to Expand) +
+ CPU Tracer Output (Click to expand) + ```bash -------------------------------------------------------------------------------------------------------------------- Tracing Histogram. Counted a total of 1135 element executions. @@ -96,12 +115,15 @@ Tracing Histogram. Counted a total of 1135 element executions. ... -------------------------------------------------------------------------------------------------------------------- ``` +
{::options parse_block_html="false" /} -#### Memory Tracer +### Memory Tracer + +Use the `--memtracer --memtracer.TraceStatements` command-line options to trace memory usage. +For example: -Use the `--memtracer --memtracer.TraceStatements` command-line options to trace memory usage. For example: ```bash graalpy --experimental-options --memtracer --memtracer.TraceStatements my_script.py ``` @@ -110,7 +132,9 @@ You should see output similar to: {::options parse_block_html="true" /} -
Memory Tracer Output (Click to Expand) +
+ Memory Tracer Output (Click to expand) + ```bash ---------------------------------------------------------------------------- Location Histogram with Allocation Counts. Recorded a total of 565 allocations. @@ -131,6 +155,7 @@ You should see output similar to: ... ---------------------------------------------------------------------------- ``` +
{::options parse_block_html="false" /} @@ -146,7 +171,10 @@ graalpy --coverage my_script.py You should see output similar to: {::options parse_block_html="true" /} -
CPU Sampler Output (Click to expand) + +
+ Coverage Output (Click to expand) + ```bash ------------------------------------------------------------------------------------------------------------------------------------------------ Code coverage histogram. @@ -196,6 +224,7 @@ Code coverage histogram. /my_script.py | 100.00% | 100.00% | 100.00% ------------------------------------------------------------------------------------------------------------------------------------------------ ``` +
{::options parse_block_html="false" /} @@ -203,7 +232,8 @@ Code coverage histogram. The standard Python `trace` module is also provided. > Note: This works in the same way as CPython. -The programmatic API also works, with some limitations: it does not currently track calls, only line counts and called functions. + +The programmatic API also works but with limitations: it currently tracks only line counts and called functions, not calls themselves. For example, running this command: @@ -214,7 +244,9 @@ graalpy -m trace -c -s text_styler.py Welcome to GraalPy! You should see output similar to: {::options parse_block_html="true" /} -
CPU Tracer Output (Click to Expand) +
+ CPU Tracer Output (Click to expand) + ```bash _ __ __ __ | | / /__ / /________ ____ ___ ___ / /_____ @@ -311,7 +343,9 @@ lines cov% module (path) 127 100% weakref (/lib/python3.10/weakref.py) 432 100% zipfile (/lib/python3.10/zipfile.py) ``` +
+ {::options parse_block_html="false" /} ## Using PyCharm with GraalPy @@ -325,19 +359,21 @@ You can use GraalPy in PyCharm to create a virtual environment, install packages 3. Create, or open, a Python project. (For more information, see [Create a Python project](https://www.jetbrains.com/help/pycharm/creating-empty-project.html), or [Open, reopen, and close projects](https://www.jetbrains.com/help/pycharm/open-projects.html), respectively.) -4. Create a new `venv` virtual environment for your Python project. -(For more information, see [Create a virtualenv environment](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html#python_create_virtual_env).) +4. Create a new virtual environment using GraalPy: + - In PyCharm settings, set the interpreter to your GraalPy installation + - Create a new `venv` virtual environment + (For more information, see [Create a virtualenv environment](https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html#python_create_virtual_env).) -5. Install packages by following the PyCharm instructions. -(For more information, see [Install, uninstall, and upgrade packages](https://www.jetbrains.com/help/pycharm/installing-uninstalling-and-upgrading-packages.html).) +5. Install packages using pip or PyCharm's package manager. + (For more information, see [Install, uninstall, and upgrade packages](https://www.jetbrains.com/help/pycharm/installing-uninstalling-and-upgrading-packages.html).) -6. Use the PyCharm menu items to [run your Python application](https://www.jetbrains.com/help/pycharm/running-applications.html). +6. Use the PyCharm menu items to [run your Python application](https://www.jetbrains.com/help/pycharm/running-applications.html). Alternatively, use the terminal emulator to run the `graalpy` command. ## Using Visual Studio Code with GraalPy You can use GraalPy in Visual Studio (VS) Code to create a virtual environment, install packages, and develop and run your Python application. - + 1. Install `graalpy`. (For more information, see [Installing GraalPy](Python-Runtime.md).) 2. Install VS Code and the Python Extension, following the instructions here: [Install Visual Studio Code and the Python Extension](https://code.visualstudio.com/docs/python/python-tutorial#_prerequisites). @@ -353,5 +389,4 @@ You can use GraalPy in Visual Studio (VS) Code to create a virtual environment, 6. Use the VS Code menu items to run your Python application. (For more information, see [Run Hello World](https://code.visualstudio.com/docs/python/python-tutorial#_run-python-code).) Alternatively, use a VS Code terminal emulator to run the `graalpy` command. -7. You cannot use VS Code to debug your Python application. -Instead, open a VS Code terminal emulator and follow these instructions: [Debugging a Python Application](#debugging). +7. You can use VS Code's built-in Python debugger to set breakpoints, inspect variables, and step through your code just like with standard Python. diff --git a/docs/user/Troubleshooting.md b/docs/user/Troubleshooting.md index 457511db8a..1b351f9183 100644 --- a/docs/user/Troubleshooting.md +++ b/docs/user/Troubleshooting.md @@ -1,72 +1,89 @@ -# GraalPy Troubleshooting +# GraalPy Embedding Troubleshooting -## GraalPy Embedding +This guide helps you resolve common issues when embedding GraalPy in Java applications. +It focuses on Virtual FileSystem setup, context configuration, build tooling, and dependency alignment for JVM-based deployments. -### VirtualFileSystem cannot load a file +## Virtual FileSystem Issues -There are situations where a file cannot be loaded even though it is part of the Virtual Filesystem resources. -GraalPy tries to prevent such situations by automatically [extracting](Embedding-Build-Tools.md#extracting-files-from-virtual-filesystem) -some well known files to the real filesystem, but if you see an error like: +### VirtualFileSystem Cannot Load Files + +Some files may fail to load from the Virtual Filesystem even though they're included as resources. +GraalPy automatically [extracts certain file types](Embedding-Build-Tools.md#extracting-files-from-virtual-filesystem) to the real filesystem, but you may still encounter errors. + +Example error: ```bash ImportError: cannot load /graalpy_vfs/venv/lib/python3.11/site-packages/_cffi_backend.graalpy250dev09433ef706-311-native-aarch64-darwin.so: NFIUnsatisfiedLinkError: dlopen(/graalpy_vfs/venv/lib/python3.11/site-packages/_cffi_backend.graalpy250dev09433ef706-311-native-aarch64-darwin.so, 0x0002): ``` -then the default behavior did not work as intended. +This indicates that the native extension requires access to the real filesystem. -Depending on how you [deploy Python resources](Embedding-Build-Tools.md#deployment) in your application, you can try one of the following: -- if you need to package resources within your Jar or Native Image executable: - - if the problematic file is not one of the following types: `.so`, `.dylib`, `.pyd`, `.dll`, or `.ttf`, which are extracted to - the real filesystem by default, you can simply attempt to add it to the extraction filter using: +**Solution**: Depending on how you [deploy Python resources](Embedding-Build-Tools.md#deployment), choose one of these approaches: - ```java - VirtualFileSystem.Builder.extractFilter(filter); - ``` +#### Option 1: Package Resources in JAR/Executable - - if the previous does not help, it is also possible to extract all Python resources into a user-defined directory before creating a GraalPy - context, and then configure the context to use that directory: +If the problematic file is not automatically extracted (files other than `.so`, `.dylib`, `.pyd`, `.dll`, or `.ttf`), add it to the extraction filter: - ```java - // extract the Python resources from the jar or native image into a given directory - GraalPyResources.extractVirtualFileSystemResources(VirtualFileSystem.create(), externalResourceDirectoryPath); - // create a GraalPy context configured with an external Python resource directory - Context context = GraalPyResources.contextBuilder(externalResourceDirectoryPath).build(); - ``` -- or if you're able to ship resources in a separate directory, you have to set the `externalDirectory` tag in - [Maven](Embedding-Build-Tools.md#graalpy-maven-plugin) or `externalDirectory` field in [Gradle](Embedding-Build-Tools.md#graalpy-gradle-plugin) - and also configure the GraalPy context to use that directory as well: +```java +VirtualFileSystem vfs = VirtualFileSystem.newBuilder() + .extractFilter(filename -> filename.endsWith(".your_extension")) + .build(); +``` - ```java - // create a Context configured with an external Python resource directory - Context context = GraalPyResources.contextBuilder(externalResourceDirectoryPath).build(); - ``` +If that doesn't resolve the issue, extract all resources to an external directory: + +```java +// Extract the Python resources from the jar or native image into a directory +GraalPyResources.extractVirtualFileSystemResources(VirtualFileSystem.create(), externalResourceDirectoryPath); +// Create a GraalPy context configured with the external directory +Context context = GraalPyResources.contextBuilder(externalResourceDirectoryPath).build(); +``` - Please **note**, that if switching from Virtual FileSystem to an external directory, also all **user files** from the previous - Virtual FileSystem resource root have to be moved into that directory as well. +#### Option 2: Use External Directory -For more details about the Python resources in GraalPy Embedding please refer to the [Embedding Build Tools](Embedding-Build-Tools.md) documentation. +Configure your build tool to use an external directory by setting: -For more details about GraalPy context and Virtual FileSystem configuration please refer to [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) and -[VirtualFileSystem](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/VirtualFileSystem.java) javadoc. +- **Maven**: `externalDirectory` tag in [Maven plugin](Embedding-Build-Tools.md#graalpy-maven-plugin) +- **Gradle**: `externalDirectory` field in [Gradle plugin](Embedding-Build-Tools.md#graalpy-gradle-plugin) -### Issues with GraalPy 'java' posix backend +Then configure your context: -The Virtual FileSystem is built on the Truffle filesystem and relies on the GraalPy Java POSIX backend. -Unfortunately, certain Python packages bypass Python's I/O and directly access files through their -native extensions. If you encounter an error like: +```java +// Create a context configured with an external Python resource directory +Context context = GraalPyResources.contextBuilder(externalResourceDirectoryPath).build(); ``` + +> **Important**: When switching from Virtual FileSystem to external directory, move all user files from the previous Virtual FileSystem resource root to the new directory. + +For more details about the Python resources in GraalPy Embedding please refer to the [Embedding Build Tools](Embedding-Build-Tools.md) documentation. + +For more details about GraalPy context and Virtual FileSystem configuration please refer to [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html) and +[VirtualFileSystem](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/VirtualFileSystem.html) javadoc. + +## POSIX Backend Issues + +### Issues with Java POSIX Backend + +The Virtual FileSystem relies on GraalPy's Java POSIX backend. +Some Python packages bypass Python's I/O and directly access files through native extensions. + +Example error: + +```bash NotImplementedError: 'PyObject_AsFileDescriptor' not supported when using 'java' posix backend ``` -then you have to override the default `java` GraalPy backend option byt setting the `native` POSIX backend -and completely omit the Virtual FileSystem at runtime. -Depending on how you [deploy Python resources](Embedding-Build-Tools.md#deployment) in your application, -you can do one of the following: +This indicates that a Python package requires direct file descriptor access which is not supported by the Java POSIX backend. + +**Solution**: Override the default Java backend by setting the native POSIX backend and extract resources from the Virtual FileSystem. + +Depending on how you [deploy Python resources](Embedding-Build-Tools.md#deployment) in your application, you can do one of the following: - if you need to package Python resources within your Jar or Native Image executable, then: + ```java - // extract the Python resources from the jar or native image into a given directory + // Extract resources and configure native backend GraalPyResources.extractVirtualFileSystemResources(VirtualFileSystem.create(), externalResourceDirectoryPath); // create a Context.Builder configured with an external python resource directory Builder builder = GraalPyResources.contextBuilder(externalResourceDirectoryPath); @@ -75,9 +92,11 @@ you can do one of the following: // create a context Context context = builder.build(); ``` + - or if you're able to ship Python resources in a separate directory, you have to set the `externalDirectory` tag in [Maven](Embedding-Build-Tools.md#graalpy-maven-plugin) or `externalDirectory` field in [Gradle](Embedding-Build-Tools.md#graalpy-gradle-plugin) and configure the GraalPy context accordingly: + ```java // create a Context.Builder configured with an external python resource directory Builder builder = GraalPyResources.contextBuilder(externalResourceDirectoryPath); @@ -86,73 +105,98 @@ you can do one of the following: // create a context Context context = builder.build(); ``` - Please **note**, that if switching from Virtual FileSystem to an external directory, also all **user files** from the previous - Virtual FileSystem resource root have to be moved into that directory as well. + +> **Important**: When switching from Virtual FileSystem to external directory, move all user files from the previous Virtual FileSystem resource root to the new directory. For more details about the Python resources in GraalPy Embedding please refer to the [Embedding Build Tools](Embedding-Build-Tools.md) documentation. -For more details about GraalPy context and Virtual FileSystem configuration please refer to [GraalPyResources](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/GraalPyResources.java) and -[VirtualFileSystem](https://github.com/oracle/graalpython/blob/master/graalpython/org.graalvm.python.embedding/src/org/graalvm/python/embedding/VirtualFileSystem.java) javadoc. +For more details about GraalPy context and Virtual FileSystem configuration please refer to [GraalPyResources](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/GraalPyResources.html) and +[VirtualFileSystem](https://oracle.github.io/graalpy-extensions/latest/org.graalvm.python.embedding/org/graalvm/python/embedding/VirtualFileSystem.html) javadoc. -### ImportError reports "unknown location" +## Import and Compatibility Issues -A possible cause of an `ImportError` ending with `(unknown location)` when running a GraalPy Java Embedding project might be -that an embedded Python package was built for a different operating system. If you see an error like the following: +### ImportError Reports "Unknown Location" + +An `ImportError` ending with `(unknown location)` typically occurs when an embedded Python package was built for a different operating system. + +Example error: ```bash ImportError: cannot import name 'exceptions' from 'cryptography.hazmat.bindings._rust' (unknown location) ``` -You probably need to rebuild your project on the correct operating system before running it. +This indicates that the Python package contains platform-specific native extensions that are incompatible with your current operating system. + +**Solution**: Rebuild your project on the target operating system before running it. + +## Dependency and Build Issues ### GraalVM JDK Compatibility -To enable runtime compilation when running GraalPy from a Maven or Gradle application, -you must use versions of GraalPy and the Polyglot API dependencies that are compatible -with the specified GraalVM JDK version. If you see errors like the following: +To enable runtime compilation when running GraalPy from a Maven or Gradle application, you must use compatible versions of GraalPy and Polyglot API dependencies with your GraalVM JDK version. + +Example error: ```bash Your Java runtime '23.0.1+11-jvmci-b01' with compiler version '24.1.1' is incompatible with polyglot version '24.1.0'. ``` -You need to keep the versions of your GraalPy and Polyglot dependencies according to the error message, -so either upgrade the version of your JDK or your polyglot and GraalPy dependencies. +This indicates version misalignment between your GraalVM JDK, compiler, and Polyglot dependencies. + +**Solution**: Align the versions of your GraalPy and Polyglot dependencies according to the error message: -Note, this can also apply to cases when your dependencies are transitively pulled in by another artifact, -e.g. micronaut-graalpy. +- Upgrade your JDK version, or +- Update your Polyglot and GraalPy dependencies -### The following artifacts could not be resolved: org.graalvm.python:python-language-enterprise +Note: This can also apply when dependencies are transitively pulled in by other artifacts, for example, `micronaut-graalpy`. -`python-language-enterprise` was discontinued, use `org.graalvm.polyglot:python` instead. +### Deprecated Dependencies -### Issues with Meson build system when installing Python packages on OSX with Maven or Gradle GraalPy plugin +You may encounter issues when using outdated or discontinued dependency artifacts in your project configuration. -Errors like the following: +Example error: + +```bash +Could not find artifact org.graalvm.python:python-language-enterprise +``` + +This indicates you're trying to use a deprecated or discontinued dependency. + +**Solution**: Replace `python-language-enterprise` with `org.graalvm.polyglot:python`. + +### macOS Build System Issues (Meson/Cython) + +On macOS, you may encounter build system errors when installing Python packages that use Meson or Cython. + +Example error: ```bash ../meson.build:1:0: ERROR: Failed running 'cython', binary or interpreter not executable. ``` -could be caused by the GraalPy launcher used internally by the Maven or Gradle GraalPy plugin -for installing Python packages. Currently, there is no straightforward solution. However, -a workaround is to set the Java system property graalpy.vfs.venvLauncher to a launcher from -a downloaded [GraalPy](https://github.com/oracle/graalpython/releases/) distribution with a version -matching the GraalPy Maven artifacts version. +This is caused by the GraalPy launcher used internally by the Maven or Gradle GraalPy plugin for installing Python packages. + +**Solution**: Set the Java system property `graalpy.vfs.venvLauncher` to a launcher from a downloaded [GraalPy](https://github.com/oracle/graalpython/releases/) distribution with a version matching your GraalPy Maven artifacts version. -e.g. +Example command: ```bash -mvn package -Dgraalpy.vfs.venvLauncher={graalpy_directroy}/Contents/Home/bin/graalpy +mvn package -Dgraalpy.vfs.venvLauncher={graalpy_directory}/Contents/Home/bin/graalpy ``` -### No language and polyglot implementation was found on the module-path. +### Missing Language Dependencies -If you see an error like: +When running GraalPy applications, you may encounter runtime errors indicating missing language implementations. + +Example error: ```bash -java.lang.IllegalStateException: No language and polyglot implementation was found on the module-path. Make sure at last one language is added to the module-path. +java.lang.IllegalStateException: No language and polyglot implementation was found on the module-path. Make sure at least one language is added to the module-path. ``` -you are probably missing the python langauge dependency in your Maven of Gradle configuration file. -You need to add either `org.graalvm.polyglot:python` or `org.graalvm.polyglot:python-community` to your dependencies. +This indicates that the Python language dependency is missing from your Maven or Gradle configuration. + +**Solution**: Add one of these dependencies to your project: +- `org.graalvm.polyglot:python` (Oracle GraalVM) +- `org.graalvm.polyglot:python-community` (Community Edition) diff --git a/docs/user/Version-Compatibility.md b/docs/user/Version-Compatibility.md new file mode 100644 index 0000000000..04370b4c7b --- /dev/null +++ b/docs/user/Version-Compatibility.md @@ -0,0 +1,9 @@ +## Version Compatibility + +The following table shows which Python versions are supported by each GraalPy release: + +| GraalPy Version | Python Version | GraalVM Platform | +| --------------- | -------------- | --------------------------------------------------------------- | +| 25.x | Python 3.12.8 | Oracle GraalVM 25.x, GraalVM Community Edition 25.x | +| 23.x | Python 3.10.8 | Oracle GraalVM for JDK 21.x, Oracle GraalVM for JDK 17.x | +| 22.x | Python 3.8.5 | GraalVM Enterprise Edition 21.3.x | \ No newline at end of file diff --git a/graalpy_virtualenv_seeder/graalpy_virtualenv_seeder/graalpy.py b/graalpy_virtualenv_seeder/graalpy_virtualenv_seeder/graalpy.py index 7d3f4ee708..1a594b8cb0 100644 --- a/graalpy_virtualenv_seeder/graalpy_virtualenv_seeder/graalpy.py +++ b/graalpy_virtualenv_seeder/graalpy_virtualenv_seeder/graalpy.py @@ -1,4 +1,4 @@ -# Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -126,6 +126,7 @@ def _native_lib(cls, lib_dir, _platform): def set_pyenv_cfg(self): # GraalPy needs an additional entry in pyvenv.cfg on Windows super().set_pyenv_cfg() + self.pyenv_cfg["base-executable"] = self.interpreter.system_executable self.pyenv_cfg["venvlauncher_command"] = self.interpreter.system_executable @@ -137,7 +138,7 @@ def set_pyenv_cfg(self): _get_default_orig = SeederSelector._get_default def _seeder_selector_get_default_override(self): - if self.interpreter.implementation == "GraalVM": + if self.interpreter.implementation.lower() in ("graalvm", "graalpy"): return "graalpy" else: return _get_default_orig() diff --git a/graalpython/AGENTS.md b/graalpython/AGENTS.md new file mode 100644 index 0000000000..3214a24ceb --- /dev/null +++ b/graalpython/AGENTS.md @@ -0,0 +1,55 @@ +# graalpython/ — SOURCE + STDLIB + TESTS + +## OVERVIEW +Main implementation tree: Java (Truffle interpreter), C (CPython C-API compatibility), and Python (stdlib overlays + tooling/tests). + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Java interpreter | `com.oracle.graal.python/src/com/oracle/graal/python/{runtime,nodes,builtins}` | Most core behavior lives here. | +| Shared Java lib nodes | `com.oracle.graal.python/src/com/oracle/graal/python/lib` | Prefer adding/reusing lib nodes for common operations. | +| C-API headers + runtime | `com.oracle.graal.python.cext/include`, `.../src` | CPython-like naming; follow CPython invariants. | +| Adapted native modules | `com.oracle.graal.python.cext/modules/` | Many files are upstream-derived; patch carefully. | +| GraalPy stdlib overlays | `lib-graalpython/` | Python files executed at startup / for builtins. | +| Vendored CPython stdlib/tests | `lib-python/3/` | Treat as upstream-ish unless explicitly changing it. | +| GraalPy tests | `com.oracle.graal.python.test/src/tests/` | Python-level tests + tag files. | +| Parser components | `com.oracle.graal.python.pegparser*` | Parser implementation + golden files tests. | + +## CONVENTIONS / GOTCHAS +- This subtree contains both “source of truth†code and vendored/upstream-ish imports; keep patches minimal in `lib-python/` and large C module imports. +- Some large headers/databases (unicode tables) are generated; avoid editing them by hand unless you also update the generator pipeline. + +## RUNNING + +- Python code can be executed with GraalPy using `mx python`, invoked just like normal `python` command. The project + *must* be first built with `mx python-jvm` or you will execute stale code. Note that `mx python-jvm` just builds, it + doesn't take arguments nor execute code. + +## TESTING + +- There are multiple kinds of tests: + - GraalPy Python tests + - Our own tests in `com.oracle.graal.python.test/src/tests/` + - Executed with `mx graalpytest test_file_name` + - New test should normally be added here, unless they need to be in Java + - CPython tests, also called tagged tests + - Tests copied from upstream CPython in `lib-python/3/tests`. Should not be modified unless specifically + requested. If modified, modifications should be marked with a `# GraalPy change` comment above the changed + part. + - Executed with `mx graalpytest --tagged test_file_name` + - Uses a "tagging" system where only a subset of tests specified in tag files is normally executed. The `--all` + flag makes it ignore the tags and execute all tests. + - JUnit tests + - In `com.oracle.graal.python.test/src` and `com.oracle.graal.python.test.integration/src` + - Used primarily for testing features exposed to Java, such as embedding, instrumentation or interop. + - The tests need to be built with `mx build` prior to execution. The `mx unittest com.example.TestName` command + can be used to run individual tests. +- The `mx graalpytest` command accepts pytest‑style test selectors (e.g., `test_mod.py::TestClass::test_method`) but is + **not** a full pytest implementation. Standard pytest command‑line flags such as `-k`, `-m`, `-v`, `--maxfail` are not + supported. +- Important: The test commands don't automatically rebuild the project. It is your reponsibility to rebuild the project + using `mx python-jvm` after making changes prior to running tests otherwise the tests will run stale code. + +## ANTI-PATTERNS +- Don’t use `mxbuild/**` outputs to understand behavior; always navigate `.../src/...` trees. +- C-API: never mix `PyMem_*` / `PyObject_*` allocators with platform `malloc` family. diff --git a/graalpython/com.oracle.graal.python.annotations/pom.xml b/graalpython/com.oracle.graal.python.annotations/pom.xml new file mode 100644 index 0000000000..09392ac931 --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/pom.xml @@ -0,0 +1,56 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.annotations + jar + diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtin.java similarity index 79% rename from graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java rename to graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtin.java index a99c4ccccd..ed2e1d673e 100644 --- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtin.java +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtin.java @@ -23,14 +23,12 @@ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ -package com.oracle.graal.python.builtins; +package com.oracle.graal.python.annotations; import java.lang.annotation.Repeatable; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import com.oracle.graal.python.nodes.StringLiterals; - @Retention(RetentionPolicy.RUNTIME) @Repeatable(value = Builtins.class) public @interface Builtin { @@ -61,8 +59,10 @@ boolean takesVarKeywordArgs() default false; + /** positional parameter names */ String[] parameterNames() default {}; + /** parameters that cannot be passed as positional ones */ String[] keywordOnlyNames() default {}; boolean isClassmethod() default false; @@ -77,10 +77,10 @@ boolean needsFrame() default false; /** - * By default the caller frame bit is set on-demand, but for some builtins it might be useful to - * always force passing the caller frame. + * By default the callerFlags bits are set on-demand, but for some builtins it might be useful + * to pre-set them. */ - boolean alwaysNeedsCallerFrame() default false; + int callerFlags() default 0; /** * Module functions should be bound to their module, meaning they would take the module itself @@ -89,17 +89,17 @@ */ boolean declaresExplicitSelf() default false; - String raiseErrorName() default StringLiterals.J_EMPTY_STRING; + String raiseErrorName() default ""; boolean forceSplitDirectCalls() default false; /** * If set to {@code true}, then this builtin will be initialized and registered in - * {@link PythonBuiltins#initialize(Python3Core)}. Otherwise, it will be ignored even when it - * has a generated node factory. This is useful when we want to initialize the builtin manually - * in different way (e.g., wrap it in method, descriptor, ...). By convention set this to - * {@code false} also for builtins declared outside of {@link PythonBuiltins} subclass to - * document the intent to not initialize them automatically. + * PythonBuiltins#initialize. Otherwise, it will be ignored even when it has a generated node + * factory. This is useful when we want to initialize the builtin manually in different way + * (e.g., wrap it in method, descriptor, ...). By convention set this to {@code false} also for + * builtins declared outside of PythonBuiltins subclass to document the intent to not initialize + * them automatically. */ boolean autoRegister() default true; } diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtins.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtins.java similarity index 95% rename from graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtins.java rename to graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtins.java index 02fe08a29e..af8e116bf3 100644 --- a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Builtins.java +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Builtins.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -38,7 +38,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -package com.oracle.graal.python.builtins; +package com.oracle.graal.python.annotations; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiConstant.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiConstant.java new file mode 100644 index 0000000000..6147b5378b --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiConstant.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Marks a Java primitive constant as the source of truth for a C {@code #define} generated into + * {@code capi.gen.h}. This is the opposite direction of {@link CApiConstants}, which marks C + * constants that should be mirrored to Java. + */ +@Retention(RetentionPolicy.SOURCE) +@Target(ElementType.FIELD) +public @interface CApiConstant { +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiExternalFunctionSignatures.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiExternalFunctionSignatures.java new file mode 100644 index 0000000000..bc093f6308 --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiExternalFunctionSignatures.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.SOURCE) +@Target(ElementType.TYPE) +public @interface CApiExternalFunctionSignatures { +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiUpcallTarget.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiUpcallTarget.java new file mode 100644 index 0000000000..a508ffa5af --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/CApiUpcallTarget.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Marks a method to be a possible upcall target. This will cause the C API annotation processor to + * generate the corresponding configuration for Native Image. + */ +@Retention(RetentionPolicy.SOURCE) +@Target(ElementType.METHOD) +public @interface CApiUpcallTarget { +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/DowncallSignature.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/DowncallSignature.java new file mode 100644 index 0000000000..274e9210bf --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/DowncallSignature.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.SOURCE) +@Target(ElementType.METHOD) +public @interface DowncallSignature { + NativeSimpleType returnType(); + + NativeSimpleType[] argumentTypes() default {}; + + Class retConversion() default void.class; + + Class[] argConversions() default {}; +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/NativeSimpleType.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/NativeSimpleType.java new file mode 100644 index 0000000000..d4750eba04 --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/NativeSimpleType.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +/** + * Simple native carrier types used by native access signatures. + *

+ * This keeps the low-level native access layer independent from C API descriptors while still + * preserving the information needed to derive Java carriers and FFM layouts. + *

+ */ +public enum NativeSimpleType { + VOID, + SINT8, + SINT16, + SINT32, + SINT64, + FLOAT, + DOUBLE, + POINTER; // raw pointer represented in Java as a long +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/PythonOS.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/PythonOS.java new file mode 100644 index 0000000000..ed7f588b74 --- /dev/null +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/PythonOS.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.annotations; + +import java.util.Locale; + +public enum PythonOS { + PLATFORM_LINUX("linux", "Linux"), + PLATFORM_DARWIN("darwin", "Darwin"), + PLATFORM_WIN32("win32", "Windows"), + PLATFORM_ANY(null, null); + + public static final String SUPPORTED_PLATFORMS = "linux/amd64, linux/aarch64, macos/aarch64, and windows/amd64"; + + private final String name; + private final String uname; + + PythonOS(String name, String uname) { + this.name = name; + this.uname = uname; + } + + public String getName() { + return name; + } + + public String getUname() { + return uname; + } + + public static final PythonOS internalCurrent; + + static { + String property = System.getProperty("os.name", "").toLowerCase(Locale.ROOT); + if (property.contains("linux")) { + internalCurrent = PLATFORM_LINUX; + } else if (property.contains("mac") || property.contains("darwin")) { + internalCurrent = PLATFORM_DARWIN; + } else if (property.contains("windows")) { + internalCurrent = PLATFORM_WIN32; + } else { + internalCurrent = PLATFORM_ANY; + } + } + + public static boolean isUnsupported() { + return internalCurrent == PLATFORM_ANY; + } + +} diff --git a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Slot.java b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Slot.java index e4deb40dd7..60bae72b51 100644 --- a/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Slot.java +++ b/graalpython/com.oracle.graal.python.annotations/src/com/oracle/graal/python/annotations/Slot.java @@ -56,7 +56,7 @@ * The slot node either needs frame for execution (e.g., may call Python code) and/or is complex * enough that indirect call to partially evaluated code is preferred over uncached execution * without frame and without setting up indirect call context. - * + * * The slot call nodes AST inline slot nodes, but if the inline cache overflows or in the * uncached case, they need to either call uncached slot node or do indirect call if * {@code isComplex} is {@code true}. @@ -97,7 +97,7 @@ boolean needsFrame() default false; - boolean alwaysNeedsCallerFrame() default false; + int callerFlags() default 0; } /** See slot documentation */ diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/fast_subprocess.py b/graalpython/com.oracle.graal.python.benchmarks/python/fast_subprocess.py new file mode 100644 index 0000000000..1d1491ab84 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/fast_subprocess.py @@ -0,0 +1,124 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# Utilities for benchmarking GraalPy startup. Creates a C benchmark runner that spawns +# the subprocesses to avoid counting subprocess module overhead into the benchmark +import os +import subprocess +import sys +import tempfile +from pathlib import Path + +RUNNER_CODE = ''' +#include +#include +#include +#include + +int main(int argc, char *argv[]) { + if (argc < 3) { + return 1; + } + int n = atoi(argv[1]); + if (n <= 0) { + return 1; + } + char **cmd_argv = &argv[2]; + for (int i = 0; i < n; ++i) { + pid_t pid = fork(); + if (pid < 0) { + perror("fork"); + return 1; + } else if (pid == 0) { + execvp(cmd_argv[0], cmd_argv); + perror("execvp"); + exit(127); // If exec fails + } else { + int status; + if (waitpid(pid, &status, 0) < 0) { + perror("waitpid"); + return 1; + } + } + } + return 0; +} +''' + +TMPDIR = tempfile.TemporaryDirectory() +RUNNER_EXE = None +ORIG_ARGV = None + + +def setup(): + global RUNNER_EXE + tmpdir = Path(TMPDIR.name) + runner_c = tmpdir / 'runner.c' + runner_c.write_text(RUNNER_CODE) + RUNNER_EXE = tmpdir / 'runner' + subprocess.check_call([os.environ.get('CC', 'gcc'), runner_c, '-O2', '-o', RUNNER_EXE]) + + global ORIG_ARGV + ORIG_ARGV = sys.orig_argv + for i, arg in enumerate(ORIG_ARGV): + if arg.endswith('.py'): + ORIG_ARGV = ORIG_ARGV[:i] + break + try: + ORIG_ARGV.remove('-snapshot-startup') + except ValueError: + pass + + +def teardown(): + TMPDIR.cleanup() + + +def run(num, code): + subprocess.check_call([ + str(RUNNER_EXE), + str(num), + *ORIG_ARGV, + "-I", # isolate from environment + "-S", # do not import site + "-B", # do not attempt to write pyc files + "-u", # do not add buffering wrappers around output streams + "-c", + code + ]) \ No newline at end of file diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/harness.py b/graalpython/com.oracle.graal.python.benchmarks/python/harness.py index 2fe1a435a6..b951cd548c 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/harness.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/harness.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -41,7 +41,7 @@ try: # https://docs.python.org/3/library/time.html#time.monotonic - # The reference point of the returned value is undefined, + # The reference point of the returned value is undefined, # so that **only the difference between the results of two calls is valid**. from time import monotonic_ns _module_start_time = monotonic_ns() @@ -143,6 +143,8 @@ def avg(values): def norm(values): _max, _min = max(values), min(values) + if _max == _min: + return zeros(len(values)) return [float(v - _min) / (_max - _min) * 100.0 for v in values] @@ -204,12 +206,32 @@ def warmup(cp_index): return -1 +def ensure_packages(**package_specs): + import sys, os + + rootdir = os.path.dirname(__file__) + while os.path.basename(rootdir) != 'graalpython': + rootdir = os.path.dirname(rootdir) + + sys.path.append(os.path.join( + rootdir, + "com.oracle.graal.python.test", + "src", + )) + from tests import ensure_packages + ensure_packages(**package_specs) + + def ccompile(name, code): import sys, os rootdir = os.path.dirname(__file__) while os.path.basename(rootdir) != 'graalpython': + prevdir = rootdir rootdir = os.path.dirname(rootdir) + if rootdir == prevdir: + # Reached the root of the file system + raise RuntimeError("'graalpython' directory not found in path!") sys.path.append(os.path.join( rootdir, @@ -236,7 +258,7 @@ def has_low_variance(durations, durations_len): class BenchRunner(object): def __init__(self, bench_file, bench_args=None, iterations=1, warmup=-1, warmup_runs=0, startup=None, - live_results=False): + live_results=False, self_measurement=False): assert isinstance(iterations, int), \ "BenchRunner iterations argument must be an int, got %s instead" % iterations assert isinstance(warmup, int), \ @@ -256,6 +278,7 @@ def __init__(self, bench_file, bench_args=None, iterations=1, warmup=-1, warmup_ self.warmup = warmup if warmup > 0 else -1 self.startup = startup self.live_results = live_results + self.self_measurement = self_measurement @staticmethod def get_bench_module(bench_file): @@ -280,6 +303,7 @@ def get_bench_module(bench_file): with _io.FileIO(bench_file, "r") as f: bench_module.__file__ = bench_file bench_module.ccompile = ccompile + bench_module.ensure_packages = ensure_packages exec(compile(f.readall(), bench_file, "exec"), bench_module.__dict__) return bench_module @@ -325,6 +349,7 @@ def report_iteration(iteration, duration): duration_str)) report_startup = bool(self.startup) + benchmark_returns_duration = self.self_measurement cleanup = False cleanup_attr = self._get_attr(ATTR_CLEANUP) @@ -354,9 +379,9 @@ def report_iteration(iteration, duration): start = monotonic_best_accuracy() result = bench_func(*args) cur_time = monotonic_best_accuracy() - duration = cur_time - start + duration = cur_time - start if not benchmark_returns_duration else result timestamps[durations_len] = cur_time - durations[durations_len] = cur_time - start + durations[durations_len] = duration durations_len += 1 if live_report: report_iteration(iteration, duration) @@ -436,6 +461,7 @@ def run_benchmark(args): bench_args = [] paths = [] live_results = False + self_measurement = False i = 0 while i < len(args): @@ -472,6 +498,8 @@ def run_benchmark(args): paths = arg.split("=")[1].split(",") elif arg == "--live-results": live_results = True + elif arg == "--self-measurement": + self_measurement = True elif bench_file is None: bench_file = arg @@ -479,6 +507,9 @@ def run_benchmark(args): bench_args.append(arg) i += 1 + if startup and self_measurement: + raise RuntimeError("It is not allowed to use the startup argument when self_measurement is enabled") + min_required_iterations = max(startup) if startup else 0 if startup and iterations < min_required_iterations: print("### WARNING: you've specified less iterations than required to measure the startup. Overriding iterations with %d" % min_required_iterations) @@ -496,8 +527,9 @@ def run_benchmark(args): if GRAALPYTHON: print(f"### using bytecode DSL interpreter: {__graalpython__.is_bytecode_dsl_interpreter}") + print(f"### using forced uncached interpreter: {getattr(__graalpython__, 'is_forced_uncached_interpreter', False)}") - BenchRunner(bench_file, bench_args=bench_args, iterations=iterations, warmup=warmup, warmup_runs=warmup_runs, startup=startup, live_results=live_results).run() + BenchRunner(bench_file, bench_args=bench_args, iterations=iterations, warmup=warmup, warmup_runs=warmup_runs, startup=startup, live_results=live_results, self_measurement=self_measurement).run() if __name__ == '__main__': diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/heap/allocate-dicts.py b/graalpython/com.oracle.graal.python.benchmarks/python/heap/allocate-dicts.py new file mode 100644 index 0000000000..3f9d67c4ae --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/heap/allocate-dicts.py @@ -0,0 +1,66 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import time + +# follows the distribution of dict sizes in import-a-lot benchmark +# +# OQL query: +# var objs = toArray(heap.objects("com.oracle.graal.python.builtins.objects.common.ObjectHashMap", false)); +# var counts = {}; +# for each (var m in objs) { +# var s = m.size; +# counts[s] = counts[s] == null ? 1 : counts[s] + 1; +# } +# map(sort(unique(map(objs, "it.size")), "lhs - rhs"), +# function (s) { return { size: s, count: counts[s] }; }) + +FACTOR = 500 +N = 256 + 8 +keys = [str(i) for i in range(N)] +small_dicts0 = [{} for i in range(22 * FACTOR)] +small_dicts1 = [{1:1} for i in range(215 * FACTOR)] +small_dicts2 = [{1:1, 2:3} for i in range(220 * FACTOR)] +small_dicts4 = [{keys[k % N]:1 for k in range(4)} for i in range(145 * FACTOR)] +small_dicts8 = [{keys[k % N]:1 for k in range(8)} for i in range(51 * FACTOR)] +dicts1 = [{(keys[k % N]):1 for k in range(8 + i % 256)} for i in range(61 * FACTOR)] + +# Sleep a bit to shake out weakref callbacks and get more measurement samples +for i in range(30): + time.sleep(0.1) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-oracledb-load.py b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-oracledb-load.py new file mode 100644 index 0000000000..db0fab8e5c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-oracledb-load.py @@ -0,0 +1,437 @@ +# Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# blog_load.py +# +# This is the code used for the blog: +# https://cjones-oracle.medium.com/direct-path-loads-fast-data-ingestion-with-python-and-oracle-database-c681fb60384f +# +# christopher.jones@oracle.com, 2025 +# +# Compare end-to-end times for reading a CSV file (number, date, string) in +# chunks and inserting into the DB. Pandas, executemany() and +# direct_path_load() are compared. +# +# The CSV file can be created using blog_create.py found at +# https://gist.github.com/cjbj/f4b605cb7db9acdf10f4ff3a2ba58d4d, inlined below into the generate_csv function +# +# Create a CSV file with 1,000,000 rows: +# python blog_create.py 1000000 +# +# Benchmark loading the CSV file in batches of 1,000,000 rows +# python blog_load.py 1000000 +# +# Benchmark loading the CSV file in batches of 500,000 rows +# python blog_load.py 500000 +# +# Install: +# python -m pip install oracledb pyarrow +# Requires python-oracledb 3.4+ + + +ensure_packages(numpy="2.2.6", cryptography="45.0.7", oracledb="3.4.2", pyarrow="20.0.0") + +import csv +from datetime import datetime +import getpass +import os +import sys +import tempfile +import time + +import pyarrow.csv + +import oracledb + +# startup database with +# $ podman run --detach --replace --name oracledb -p 1521:1521 -e ORACLE_PWD=graalpy \ +# container-registry.oracle.com/database/free:23.26.0.0 +USERNAME = os.environ.get("PYO_TEST_ADMIN_USER", "system") +CONNECTSTRING = os.environ.get("PYO_TEST_CONNECT_STRING", "127.0.0.1:1521/FREEPDB1") +PASSWORD = os.environ.get("PYO_TEST_ADMIN_PASSWORD", "graalpy") + +# ----------------------------------------------------------------------------- + +FILE_NAME = os.path.join(tempfile.gettempdir(), "graalpy-c-oracledb-load-sample.csv") +BATCH_SIZE = 2_000_000 +TABLES = ["mytabpya", "mytabdpl", "mytabpyaem", "mytabem", "mytabpd"] + +def __process_args__(batch_size=BATCH_SIZE): + return [int(str(batch_size).replace("_", ""))] + +# ----------------------------------------------------------------------------- + +def createtab(connection, tab): + with connection.cursor() as cursor: + cursor.execute(f"""drop table if exists {tab} purge""") # 23ai syntax + cursor.execute(f"""create table {tab} ( + id number, + dt date, + name varchar2(50))""") + +# ----------------------------------------------------------------------------- + +def droptabs(connection, tabs): + with connection.cursor() as cursor: + for tab in tabs: + cursor.execute(f"drop table if exists {tab} purge") # 23ai syntax + +# ----------------------------------------------------------------------------- + +def checkrowcount(connection, tab): + r, = connection.cursor().execute(f"select count(*) from {tab}").fetchone() + print(f"{r} rows were inserted") + +# ----------------------------------------------------------------------------- + +# Compare tables +def compare(connection, t1, t2): + print(f"\nChecking '{t1}' and '{t2}'") + + sql = f"""( + select * from {t1} + minus + select * from {t2} + ) union all ( + select * from {t2} + minus + select * from {t1} + )""" + + with connection.cursor() as cursor: + for r in cursor.execute(sql): + print(f"Tables '{t1}' and '{t2}' differ") + print(r) + exit() + + print(f"Tables are the same") + +# ----------------------------------------------------------------------------- +# Using Pandas to read and insert + +def pd(tab): + print("\nPandas read_csv() - Pandas to_sql()") + + ensure_packages(pandas="2.2.3", sqlalchemy="2.0.45") + import pandas + from sqlalchemy import create_engine + + engine = create_engine( + "oracle+oracledb://@", + connect_args={ + "user": USERNAME, + "password": PASSWORD, + "dsn": CONNECTSTRING, + }, + # echo=True + ) + + start = time.perf_counter_ns() + + csv_reader = pandas.read_csv( + FILE_NAME, + header=None, + names=["id", "dt", "name"], + parse_dates=['dt'], + chunksize=BATCH_SIZE) + for df in csv_reader: + df.to_sql(tab, engine, if_exists='append', index=False) + + elapsed = (time.perf_counter_ns() - start) / 1_000_000 + print(f"Loaded in batches of size {BATCH_SIZE}") + print(f"Total elapsed time: {elapsed:,.1f} ms") + +# ----------------------------------------------------------------------------- +# Using Python's CSV package to read into a list and then calling executemany() + +def em(connection, tab): + print("\nPython CSV loader to list - executemany()") + + start = time.perf_counter_ns() + + cursor = connection.cursor() + + cursor.setinputsizes(None, None, 50) + + sql = f"insert into {tab} (id, dt, name) values (:1, :2, :3)" + data = [] + batch_number = 0 + csv_reader = csv.reader(open(FILE_NAME, "r"), delimiter=",") + for line in csv_reader: + data.append((float(line[0]), datetime.strptime(line[1], "%d-%b-%Y"), line[2])) + if len(data) % BATCH_SIZE == 0: + cursor.executemany(sql, data) + data = [] + batch_number += 1 + if data: + cursor.executemany(sql, data) + batch_number += 1 + + connection.commit() + + elapsed = (time.perf_counter_ns() - start) / 1_000_000 + print(f"Loaded in {batch_number} batches of size {BATCH_SIZE}") + print(f"Total elapsed time: {elapsed:,.1f} ms") + +# ----------------------------------------------------------------------------- +# Using PyArrow to read into Dataframe and then calling executemany() + +def pyaem(connection, tab): + print("\nPyArrow CSV loader to DataFrame - executemany()") + + start = time.perf_counter_ns() + + sql = f"insert into {tab} (id, dt, name) values (:1, :2, :3)" + colnames=["id", "dt", "name"] + + read_options = pyarrow.csv.ReadOptions( + column_names=colnames, + block_size=BLOCK_SIZE + ) + + convert_options = pyarrow.csv.ConvertOptions( + timestamp_parsers=["%d-%b-%Y"], + column_types={ + "id": pyarrow.int64(), + "dt": pyarrow.timestamp("us"), + "name": pyarrow.string() + } + ) + + cursor = connection.cursor() + + batch_number = 0 + csv_reader = pyarrow.csv.open_csv(FILE_NAME, read_options=read_options, convert_options=convert_options) + for df in csv_reader: + if df is None: + break + batch_number += 1 + cursor.executemany(sql, df) + + connection.commit() + + elapsed = (time.perf_counter_ns() - start) / 1_000_000 + print(f"Loaded in {batch_number} batches with block size {BLOCK_SIZE}") + print(f"Total elapsed time: {elapsed:,.1f} ms") + +# ----------------------------------------------------------------------------- +# Using Python's CSV package to read into a list and then a Direct Path Load +# + +def dpl(connection, tab): + print("\nPython CSV loader to list - Direct Path Load") + + start = time.perf_counter_ns() + + column_names = ["id", "dt", "name"] + data = [] + batch_number = 0 + csv_reader = csv.reader(open(FILE_NAME, "r"), delimiter=",") + for line in csv_reader: + data.append((float(line[0]), datetime.strptime(line[1], "%d-%b-%Y"), line[2])) + if len(data) % BATCH_SIZE == 0: + connection.direct_path_load( + schema_name=USERNAME, + table_name=tab, + column_names=column_names, + data=data) + batch_number += 1 + data = [] + if data: + connection.direct_path_load( + schema_name=USERNAME, + table_name=tab, + column_names=column_names, + data=data) + batch_number += 1 + + print(f"Loaded in {batch_number} batches of size {BATCH_SIZE}") + elapsed = (time.perf_counter_ns() - start) / 1_000_000 + print(f"Total elapsed time: {elapsed:,.1f} ms") + +# ----------------------------------------------------------------------------- +# Using PyArrow to read into Dataframe and then a Direct Path Load + +def pya(connection, tab): + print("\nPyArrow CSV loader to DataFrame - Direct Path Load ") + + start = time.perf_counter_ns() + + column_names=["id", "dt", "name"] + + read_options = pyarrow.csv.ReadOptions( + column_names=column_names, + block_size=BLOCK_SIZE + ) + + convert_options = pyarrow.csv.ConvertOptions( + timestamp_parsers=["%d-%b-%Y"], + column_types={ + "id": pyarrow.int64(), + "dt": pyarrow.timestamp("us"), + "name": pyarrow.string() + } + ) + + csv_reader = pyarrow.csv.open_csv(FILE_NAME, read_options=read_options, convert_options=convert_options) + batch_number = 0 + for df in csv_reader: + if df is None: + break + batch_number += 1 + connection.direct_path_load( + schema_name=USERNAME, + table_name=tab, + column_names=column_names, + data=df) + + elapsed = (time.perf_counter_ns() - start) / 1_000_000 + print(f"Loaded in {batch_number} batches with block size {BLOCK_SIZE}") + print(f"Total elapsed time: {elapsed:,.1f} ms") + +# ----------------------------------------------------------------------------- + +BLOCK_SIZE = 0 +CONNECTION = None + +def __setup__(batch_size=BATCH_SIZE): + global BATCH_SIZE + BATCH_SIZE = batch_size + + # blog_create.py + # + # christopher.jones@oracle.com, 2025 + # + # Create a CSV file (number, date, string) + import csv + import sys + from datetime import datetime + + + num_records = BATCH_SIZE + data = [ + ( + i + 1, + datetime.now().strftime("%d-%b-%Y"), + f"String for row {i + 1}" + ) for i in range(num_records) + ] + + with open(FILE_NAME, "w") as f: + writer = csv.writer( + f, lineterminator="\n", quoting=csv.QUOTE_NONNUMERIC + ) + writer.writerows(data) + + print(f"Created {FILE_NAME} with {num_records} records") + + global BLOCK_SIZE, CONNECTION + BLOCK_SIZE = len(max(open(FILE_NAME, 'r'), key=len)) * BATCH_SIZE + timeout = float(os.environ.get("GRAALPY_ORACLEDB_WAIT_TIMEOUT", "0")) + deadline = time.monotonic() + timeout + attempt = 0 + while True: + try: + CONNECTION = oracledb.connect(user=USERNAME, password=PASSWORD, dsn=CONNECTSTRING) + break + except oracledb.Error: + if time.monotonic() >= deadline: + raise + attempt += 1 + print(f"Waiting for Oracle Database at {CONNECTSTRING} (attempt {attempt})") + time.sleep(5) + + quiet_seconds = float(os.environ.get("GRAALPY_ORACLEDB_QUIET_SECONDS", "0")) + if quiet_seconds > 0: + print(f"Waiting {quiet_seconds:g} seconds for Oracle Database to settle") + time.sleep(quiet_seconds) + + +def __benchmark__(batch_size=BATCH_SIZE): + assert batch_size == BATCH_SIZE + t1 = TABLES[0] + createtab(CONNECTION, t1) + pya(CONNECTION, t1) + checkrowcount(CONNECTION, t1) + + t2 = TABLES[1] + # createtab(CONNECTION, t2) + # dpl(CONNECTION, t2) + # checkrowcount(CONNECTION, t2) + + t3 = TABLES[2] + # createtab(CONNECTION, t3) + # pyaem(CONNECTION, t3) + # checkrowcount(CONNECTION, t3) + + t4 = TABLES[3] + # createtab(CONNECTION, t4) + # em(CONNECTION, t4) + # checkrowcount(CONNECTION, t4) + + t5 = TABLES[4] + # createtab(CONNECTION, t5) + # pd(t5) + # checkrowcount(CONNECTION, t5) + + # Check all the tables are the same + #compare(CONNECTION, t1, t2); compare(CONNECTION, t2, t3); compare(CONNECTION, t3, t4); compare(CONNECTION, t4, t5) + + +def __cleanup__(*args): + if CONNECTION is not None: + droptabs(CONNECTION, TABLES) + + +def __teardown__(): + global CONNECTION + if CONNECTION is not None: + CONNECTION.close() + CONNECTION = None + + +if __name__ == "__main__": + if len(sys.argv) > 1: + BATCH_SIZE = int(sys.argv[1]) + __setup__(BATCH_SIZE) + print("\nCompare end-to-end times for reading a " + "CSV file (number, date, string) in chunks and inserting into the Database") + __benchmark__(BATCH_SIZE) + __cleanup__() + __teardown__() diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pydantic-validate.py b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pydantic-validate.py new file mode 100644 index 0000000000..2eb03b5f0b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pydantic-validate.py @@ -0,0 +1,57 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +ensure_packages(pydantic="2.12.5") +from pydantic import BaseModel, ValidationError + + +class User(BaseModel): + id: int + name: str + email: str + active: bool + + +def __benchmark__(iterations=200000): + for i in range(iterations): + try: + u = User(id=i, name=f"User {i}", email=f"user{i}@example.com", active=True) + except ValidationError: + pass + return u diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pymupdf-parse.py b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pymupdf-parse.py new file mode 100644 index 0000000000..d576159f8f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/macro/c-pymupdf-parse.py @@ -0,0 +1,81 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import io +import os +import subprocess + + +def find_cpython3_on_path(): + exe_name = "python3" + paths = os.environ["PATH"].split(os.pathsep) + for path in paths: + exe_path = os.path.join(path, exe_name) + if "cpython" in subprocess.getoutput(f"'{exe_path}' -c 'import sys;print(sys.implementation.name)'"): + return exe_path + + +os.environ["CPYTHON_EXE"] = find_cpython3_on_path() +ensure_packages(pymupdf="1.25.4", pymupdf4llm="0.0.18") + + +import pymupdf +import pymupdf4llm + +PDF_BYTES = None + + +def parse_pdf(): + pdf_stream = io.BytesIO(PDF_BYTES) + docType = "pdf" + doc = pymupdf.open(stream=pdf_stream, filetype=docType) + # doc = pymupdf.open("./sample.txt") + md_text = pymupdf4llm.to_markdown(doc, show_progress = True) + doc.close() + return md_text + + +def __setup__(*args): + global PDF_BYTES + with open(os.path.join(os.path.dirname(__file__), "sample.txt"), "rb") as f: + PDF_BYTES = f.read() + + +def __benchmark__(num=1): + parse_pdf() diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/macro/sample.txt b/graalpython/com.oracle.graal.python.benchmarks/python/macro/sample.txt new file mode 100644 index 0000000000..e0940624bf Binary files /dev/null and b/graalpython/com.oracle.graal.python.benchmarks/python/macro/sample.txt differ diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/3d_surface_wireframe.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/3d_surface_wireframe.py new file mode 100644 index 0000000000..96ac2bdb65 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/3d_surface_wireframe.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +3D plotting example: surface, wireframe, and contour projections. +Saves to PDF. +""" + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "surface_3d.pdf" + + # Domain and function + x = np.linspace(-4, 4, 200) + y = np.linspace(-4, 4, 200) + X, Y = np.meshgrid(x, y) + + R = np.sqrt(X**2 + Y**2) + 1e-12 + Z = np.sin(R) / R + 0.15 * np.cos(3*X) * np.sin(3*Y) / (1 + 0.5 * (X**2 + Y**2)) + + fig = plt.figure(figsize=(7.5, 5.8), dpi=150) + ax = fig.add_subplot(111, projection="3d") + + # Surface with colormap + surf = ax.plot_surface(X, Y, Z, cmap="viridis", linewidth=0, antialiased=True, alpha=0.95) + + # Wireframe overlay (sparser grid to avoid clutter) + step = 10 + ax.plot_wireframe(X[::step, ::step], Y[::step, ::step], Z[::step, ::step], + rstride=1, cstride=1, color="k", linewidth=0.3, alpha=0.5) + + # Contour projections on Z, X, and Y planes + z_offset = Z.min() - 0.4 + ax.contour(X, Y, Z, zdir="z", offset=z_offset, cmap="viridis", levels=18, linewidths=0.8) + + x_offset = x.min() - 0.6 + ax.contour(X, Y, Z, zdir="x", offset=x_offset, cmap="magma", levels=14, linewidths=0.7) + + y_offset = y.max() + 0.6 + ax.contour(X, Y, Z, zdir="y", offset=y_offset, cmap="plasma", levels=14, linewidths=0.7) + + # Axes labels and limits + ax.set_xlabel("X") + ax.set_ylabel("Y") + ax.set_zlabel("Z") + + ax.set_xlim(x_offset, x.max()) + ax.set_ylim(y.min(), y_offset) + ax.set_zlim(z_offset, Z.max()) + + # Colorbar + cb = fig.colorbar(surf, ax=ax, shrink=0.6, aspect=12, pad=0.08) + cb.set_label("Z value") + + # View angle + ax.view_init(elev=25, azim=-55) + + ax.set_title("3D Surface + Wireframe + Contour Projections") + fig.tight_layout() + + fig.savefig(out_path, format="pdf") + plt.close(fig) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/OWNERS.toml b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/OWNERS.toml new file mode 100644 index 0000000000..34cb11f338 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "*" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/categorical_bar_and_box.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/categorical_bar_and_box.py new file mode 100644 index 0000000000..6fa26ce37a --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/categorical_bar_and_box.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Categorical plots: grouped bar chart with error bars and a boxplot. +Saves a multi-page PDF using PdfPages. +""" + + +def _colorize_boxplot(bp, facecolor="#1f77b4", edgecolor="black", alpha=0.6): + for box in bp["boxes"]: + box.set(facecolor=facecolor, edgecolor=edgecolor, alpha=alpha) + for median in bp["medians"]: + median.set(color="black", linewidth=1.2) + for whisker in bp["whiskers"]: + whisker.set(color=edgecolor, linewidth=1.0) + for cap in bp["caps"]: + cap.set(color=edgecolor, linewidth=1.0) + for flier in bp["fliers"]: + flier.set(marker="o", markersize=3, markerfacecolor="white", markeredgecolor=edgecolor, alpha=0.7) + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + from matplotlib.backends.backend_pdf import PdfPages + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "categorical_plots.pdf" + + rng = np.random.default_rng(2024) + categories = ["A", "B", "C", "D"] + n = len(categories) + + with PdfPages(out_path) as pdf: + # Page 1: Grouped bar chart with error bars + x = np.arange(n) + bar_w = 0.35 + + means1 = rng.normal(3.0, 0.4, n) + errs1 = rng.uniform(0.1, 0.4, n) + + means2 = rng.normal(2.2, 0.5, n) + errs2 = rng.uniform(0.1, 0.4, n) + + fig1, ax1 = plt.subplots(figsize=(7, 4), dpi=150) + b1 = ax1.bar(x - bar_w / 2, means1, yerr=errs1, width=bar_w, capsize=3, + label="Series 1", color="#1f77b4", edgecolor="black", alpha=0.85) + b2 = ax1.bar(x + bar_w / 2, means2, yerr=errs2, width=bar_w, capsize=3, + label="Series 2", color="#ff7f0e", edgecolor="black", alpha=0.85) + + ax1.set_xticks(x, categories) + ax1.set_ylabel("Value") + ax1.set_title("Grouped Bar Chart with Error Bars") + ax1.grid(axis="y", linestyle="--", alpha=0.35) + ax1.legend(loc="best") + + # Annotate bars with heights + for bars in (b1, b2): + for rect in bars: + h = rect.get_height() + ax1.text(rect.get_x() + rect.get_width() / 2.0, h + 0.05, + f"{h:.2f}", ha="center", va="bottom", fontsize=8, rotation=0) + + fig1.tight_layout() + pdf.savefig(fig1) + plt.close(fig1) + + # Page 2: Boxplot across categories + # Generate some synthetic distributions with varying mean/variance + mus = [2.8, 3.2, 2.5, 3.5] + sigmas = [0.50, 0.60, 0.45, 0.55] + data = [rng.normal(loc=m, scale=s, size=400) for m, s in zip(mus, sigmas)] + + fig2, ax2 = plt.subplots(figsize=(7, 4), dpi=150) + bp = ax2.boxplot( + data, + labels=categories, + widths=0.6, + patch_artist=True, + showfliers=True, + whis=(5, 95), + ) + # Colorize boxes with a palette + palette = ["#1f77b4", "#ff7f0e", "#2ca02c", "#9467bd"] + for box, color in zip(bp["boxes"], palette): + box.set(facecolor=color, edgecolor="black", alpha=0.6) + + # Style the rest + for median in bp["medians"]: + median.set(color="black", linewidth=1.4) + for whisker in bp["whiskers"]: + whisker.set(color="black", linewidth=1.0) + for cap in bp["caps"]: + cap.set(color="black", linewidth=1.0) + for flier in bp["fliers"]: + flier.set(marker="o", markersize=3, markerfacecolor="white", markeredgecolor="black", alpha=0.7) + + ax2.set_title("Boxplot by Category") + ax2.set_ylabel("Distribution") + ax2.grid(axis="y", linestyle="--", alpha=0.35) + fig2.tight_layout() + + pdf.savefig(fig2) + plt.close(fig2) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/distributions_hist_2d.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/distributions_hist_2d.py new file mode 100644 index 0000000000..092d2aa746 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/distributions_hist_2d.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Distribution plots: 1D histogram, 2D histogram, and hexbin with colorbars. +""" + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "distributions_2d.pdf" + + rng = np.random.default_rng(7) + n = 6000 + + # Create two correlated variables + x = rng.normal(0.0, 1.0, n) + y = 0.65 * x + rng.normal(0.0, 0.8, n) + + fig, axs = plt.subplots(1, 3, figsize=(12, 4), dpi=150) + + # 1) 1D histograms overlayed + ax = axs[0] + ax.hist(x, bins=40, alpha=0.8, label="x", color="#1f77b4", edgecolor="white") + ax.hist(y, bins=40, alpha=0.6, label="y", color="#ff7f0e", edgecolor="white") + ax.set_title("1D Histograms") + ax.set_xlabel("Value") + ax.set_ylabel("Frequency") + ax.grid(True, linestyle="--", alpha=0.3) + ax.legend(loc="best") + + # 2) 2D histogram via pcolormesh + ax = axs[1] + H, xedges, yedges = np.histogram2d(x, y, bins=60) + X, Y = np.meshgrid(xedges, yedges) + pcm = ax.pcolormesh(X, Y, H.T, cmap="viridis", shading="auto") + ax.set_title("2D Histogram") + ax.set_xlabel("x") + ax.set_ylabel("y") + cb = fig.colorbar(pcm, ax=ax) + cb.set_label("Count") + ax.grid(False) + + # 3) Hexbin with log color scale + ax = axs[2] + hb = ax.hexbin(x, y, gridsize=45, cmap="plasma", mincnt=1, bins="log") + ax.set_title("Hexbin (log density)") + ax.set_xlabel("x") + ax.set_ylabel("y") + cb = fig.colorbar(hb, ax=ax) + cb.set_label("log10(count)") + ax.grid(False) + + fig.suptitle("Distributions: 1D and 2D Density", fontsize=14) + fig.tight_layout(rect=[0, 0.03, 1, 0.95]) + + fig.savefig(out_path, format="pdf") + plt.close(fig) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/polar_quiver_stream.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/polar_quiver_stream.py new file mode 100644 index 0000000000..192d984f63 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/polar_quiver_stream.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Vector and polar plots: polar plot, quiver, and streamplot on separate pages. +Saves a multi-page PDF using PdfPages. +""" + + +def page_polar(ax): + # Polar demo with multiple radii and an area fill + import numpy as np + theta = np.linspace(0, 2*np.pi, 512) + r1 = 1.0 + 0.3*np.sin(5*theta) + r2 = 0.7 + 0.2*np.cos(3*theta + 0.5) + + ax.plot(theta, r1, color="#1f77b4", linewidth=2.0, label="r1(θ) = 1 + 0.3 sin(5θ)") + ax.plot(theta, r2, color="#ff7f0e", linewidth=2.0, linestyle="--", label="r2(θ) = 0.7 + 0.2 cos(3θ+0.5)") + ax.fill_between(theta, r2, color="#ff7f0e", alpha=0.25, step="mid") + ax.set_theta_zero_location("N") + ax.set_theta_direction(-1) + ax.set_title("Polar Plot", va="bottom") + ax.grid(True, alpha=0.4) + ax.legend(loc="upper right", bbox_to_anchor=(1.25, 1.15), frameon=False) + + +def page_quiver(ax): + # Quiver plot for a simple rotational vector field + import numpy as np + n = 25 + x = np.linspace(-2.0, 2.0, n) + y = np.linspace(-2.0, 2.0, n) + X, Y = np.meshgrid(x, y) + + # Vector field: rotation around origin + U = -Y + V = X + speed = np.hypot(U, V) + + q = ax.quiver(X, Y, U, V, speed, cmap="viridis", pivot="mid", angles="xy", scale=35, width=0.006) + ax.set_aspect("equal", adjustable="box") + ax.set_title("Quiver: Rotational Field") + ax.set_xlabel("x") + ax.set_ylabel("y") + cb = ax.figure.colorbar(q, ax=ax, pad=0.01) + cb.set_label("|v|") + ax.grid(True, linestyle="--", alpha=0.3) + + +def page_streamplot(ax): + # Streamplot with linewidth and color mapped to speed + import numpy as np + x = np.linspace(-3.0, 3.0, 200) + y = np.linspace(-3.0, 3.0, 200) + X, Y = np.meshgrid(x, y) + + # Double-vortex-like field + U = 1 - (X**2) + (Y**2) + V = -2*X*Y + speed = np.sqrt(U**2 + V**2) + + lw = 1.5 * speed / (speed.max() + 1e-12) + strm = ax.streamplot(X, Y, U, V, color=speed, linewidth=lw, cmap="plasma", density=1.4, arrowsize=1.2) + ax.set_aspect("equal", adjustable="box") + ax.set_title("Streamplot: Speed-coded") + ax.set_xlabel("x") + ax.set_ylabel("y") + cb = ax.figure.colorbar(strm.lines, ax=ax, pad=0.01) + cb.set_label("|v|") + ax.grid(True, linestyle="--", alpha=0.25) + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + from matplotlib.backends.backend_pdf import PdfPages + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "vector_and_polar.pdf" + + with PdfPages(out_path) as pdf: + # Page 1: Polar + fig1 = plt.figure(figsize=(6.2, 5.5), dpi=150) + ax1 = fig1.add_subplot(111, projection="polar") + page_polar(ax1) + fig1.tight_layout() + pdf.savefig(fig1) + plt.close(fig1) + + # Page 2: Quiver + fig2, ax2 = plt.subplots(figsize=(6.2, 5.0), dpi=150) + page_quiver(ax2) + fig2.tight_layout() + pdf.savefig(fig2) + plt.close(fig2) + + # Page 3: Streamplot + fig3, ax3 = plt.subplots(figsize=(6.6, 5.2), dpi=150) + page_streamplot(ax3) + fig3.tight_layout() + pdf.savefig(fig3) + plt.close(fig3) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/simple_line_plot.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/simple_line_plot.py new file mode 100644 index 0000000000..8333b80f53 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/simple_line_plot.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Simple line plot example that saves to PDF. +""" + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "simple_line_plot.pdf" + + # Reproducible data + rng = np.random.default_rng(42) + x = np.linspace(0.0, 10.0, 200) + y = np.sin(x) + 0.15 * rng.standard_normal(x.size) + + plt.figure(figsize=(6, 4), dpi=150) + plt.plot(x, np.sin(x), label="sin(x)", color="#1f77b4", linewidth=2.0) + plt.scatter(x[::8], y[::8], label="samples", color="#ff7f0e", s=15, alpha=0.85) + plt.title("Simple Line + Sampled Points") + plt.xlabel("x") + plt.ylabel("y") + plt.grid(True, linestyle="--", alpha=0.4) + plt.legend(loc="best") + plt.tight_layout() + + plt.savefig(out_path, format="pdf") + plt.close() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/subplots_and_styles.py b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/subplots_and_styles.py new file mode 100644 index 0000000000..011a2b612b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/matplotlib/subplots_and_styles.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Subplots and style variations; saves a multi-panel PDF. +""" + + +def run(): + # Execute all imports inside the `run` method so they're measured + from pathlib import Path + # Use a non-interactive backend to work in headless environments + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + import numpy as np + + # Ensure we have version info in the logs + print(f"Using matplotlib version '{matplotlib.__version__}'") + print(f"Using numpy version '{np.__version__}'") + + out_path = Path(__file__).parent / "subplots_and_styles.pdf" + + rng = np.random.default_rng(123) + x = np.linspace(0, 2*np.pi, 200) + y1 = np.sin(x) + y2 = np.cos(x) + y3 = np.sin(2*x) * np.exp(-0.3*x) + y4 = rng.normal(loc=0.0, scale=1.0, size=200) + + fig, axs = plt.subplots(2, 2, figsize=(8, 6), dpi=150) + + # 1) Basic line styles + ax = axs[0, 0] + ax.plot(x, y1, label="sin(x)", color="#1f77b4", linewidth=2.0) + ax.plot(x, y2, label="cos(x)", color="#ff7f0e", linestyle="--", linewidth=2.0) + ax.set_title("Line Styles") + ax.set_xlabel("x") + ax.set_ylabel("y") + ax.grid(True, linestyle=":", alpha=0.5) + ax.legend(loc="best") + + # 2) Markers and transparency + ax = axs[0, 1] + ax.plot(x, y3, color="#2ca02c", linewidth=1.5) + ax.scatter(x[::10], y3[::10], color="#d62728", s=20, alpha=0.8, label="samples") + ax.set_title("Markers and Decay") + ax.annotate("decay", xy=(2.0, y3[np.searchsorted(x, 2.0)]), xytext=(3.5, 0.8), + arrowprops=dict(arrowstyle="->", color="gray"), color="gray") + ax.grid(True, alpha=0.4) + ax.legend(loc="best") + + # 3) Simple bar chart + ax = axs[1, 0] + categories = ["A", "B", "C", "D", "E"] + values = np.abs(rng.normal(3.0, 1.0, size=len(categories))) + bars = ax.bar(categories, values, color="#9467bd", edgecolor="black", alpha=0.85) + for b in bars: + ax.text(b.get_x() + b.get_width()/2, b.get_height() + 0.05, + f"{b.get_height():.1f}", ha="center", va="bottom", fontsize=8) + ax.set_title("Bar Chart") + ax.set_ylabel("Value") + ax.set_ylim(0, max(values) * 1.2) + ax.grid(axis="y", linestyle="--", alpha=0.3) + + # 4) Histogram with style + ax = axs[1, 1] + ax.hist(y4, bins=20, color="#8c564b", edgecolor="white", alpha=0.9) + ax.set_title("Histogram") + ax.set_xlabel("Value") + ax.set_ylabel("Frequency") + ax.grid(True, linestyle="--", alpha=0.3) + + fig.suptitle("Subplots and Styles", fontsize=14) + fig.tight_layout(rect=[0, 0.03, 1, 0.95]) + + fig.savefig(out_path, format="pdf") + plt.close(fig) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/meso/chaos-traced.py b/graalpython/com.oracle.graal.python.benchmarks/python/meso/chaos-traced.py new file mode 100644 index 0000000000..92d05ddb5f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/meso/chaos-traced.py @@ -0,0 +1,283 @@ +# Copyright (c) 2020, 2026, Oracle and/or its affiliates. +# Copyright (c) 2017, The PyPy Project +# +# The MIT License +# Permission is hereby granted, free of charge, to any person +# obtaining a copy of this software and associated documentation +# files (the "Software"), to deal in the Software without +# restriction, including without limitation the rights to use, +# copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. + +# Copyright (C) 2005, Carl Friedrich Bolz +# Variant of the chaos-sized2 benchmark with tracing enabled + +"""create chaosgame-like fractals +""" + +from __future__ import division, print_function + +import sys +import operator +import random +import math +from functools import reduce + +random.seed(1234) + +class GVector(object): + def __init__(self, x = 0, y = 0, z = 0): + self.x = x + self.y = y + self.z = z + + def Mag(self): + return math.sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2) + + def dist(self, other): + return math.sqrt((self.x - other.x) ** 2 + + (self.y - other.y) ** 2 + + (self.z - other.z) ** 2) + + def __add__(self, other): + if not isinstance(other, GVector): + raise ValueError( "Can't add GVector to " + str(type(other))) + v = GVector(self.x + other.x, self.y + other.y, self.z + other.z) + return v + + def __sub__(self, other): + return self + other * -1 + + def __mul__(self, other): + v = GVector(self.x * other, self.y * other, self.z * other) + return v + __rmul__ = __mul__ + + def linear_combination(self, other, l1, l2=None): + if l2 is None: + l2 = 1 - l1 + v = GVector(self.x * l1 + other.x * l2, + self.y * l1 + other.y * l2, + self.z * l1 + other.z * l2) + return v + + + def __str__(self): + return "<%f, %f, %f>" % (self.x, self.y, self.z) + + def __repr__(self): + return "GVector(%f, %f, %f)" % (self.x, self.y, self.z) + +def GetKnots(points, degree): + knots = [0] * degree + range(1, len(points) - degree) + knots += [len(points) - degree] * degree + return knots + +class Spline(object): + """Class for representing B-Splines and NURBS of arbitrary degree""" + def __init__(self, points, degree = 3, knots = None): + """Creates a Spline. points is a list of GVector, degree is the +degree of the Spline.""" + if knots == None: + self.knots = GetKnots(points, degree) + else: + if len(points) > len(knots) - degree + 1: + raise ValueError("too many control points") + elif len(points) < len(knots) - degree + 1: + raise ValueError("not enough control points") + last = knots[0] + for cur in knots[1:]: + if cur < last: + raise ValueError("knots not strictly increasing") + last = cur + self.knots = knots + self.points = points + self.degree = degree + + def GetDomain(self): + """Returns the domain of the B-Spline""" + return (self.knots[self.degree - 1], + self.knots[len(self.knots) - self.degree]) + + def __call__(self, u): + """Calculates a point of the B-Spline using de Boors Algorithm""" + dom = self.GetDomain() + if u < dom[0] or u > dom[1]: + raise ValueError("Function value not in domain") + if u == dom[0]: + return self.points[0] + if u == dom[1]: + return self.points[-1] + I = self.GetIndex(u) + d = [self.points[I - self.degree + 1 + ii] + for ii in range(self.degree + 1)] + U = self.knots + for ik in range(1, self.degree + 1): + for ii in range(I - self.degree + ik + 1, I + 2): + ua = U[ii + self.degree - ik] + ub = U[ii - 1] + co1 = (ua - u) / (ua - ub) + co2 = (u - ub) / (ua - ub) + index = ii - I + self.degree - ik - 1 + d[index] = d[index].linear_combination(d[index + 1], co1, co2) + return d[0] + + def GetIndex(self, u): + dom = self.GetDomain() + for ii in range(self.degree - 1, len(self.knots) - self.degree): + if u >= self.knots[ii] and u < self.knots[ii + 1]: + I = ii + break + else: + I = dom[1] - 1 + return I + + def __len__(self): + return len(self.points) + + def __repr__(self): + return "Spline(%r, %r, %r)" % (self.points, self.degree, self.knots) + + +class Chaosgame(object): + def __init__(self, splines, thickness=0.1): + self.splines = splines + self.thickness = thickness + self.minx = min([p.x for spl in splines for p in spl.points]) + self.miny = min([p.y for spl in splines for p in spl.points]) + self.maxx = max([p.x for spl in splines for p in spl.points]) + self.maxy = max([p.y for spl in splines for p in spl.points]) + self.height = self.maxy - self.miny + self.width = self.maxx - self.minx + self.num_trafos = [] + maxlength = thickness * self.width / self.height + for spl in splines: + length = 0 + curr = spl(0) + for i in range(1, 1000): + last = curr + t = 1 / 999 * i + curr = spl(t) + length += curr.dist(last) + self.num_trafos.append(max(1, int(length / maxlength * 1.5))) + self.num_total = reduce(operator.add, self.num_trafos, 0) + + + def get_random_trafo(self): + r = random.randrange(int(self.num_total) + 1) + l = 0 + for i in range(len(self.num_trafos)): + if r >= l and r < l + self.num_trafos[i]: + return i, random.randrange(self.num_trafos[i]) + l += self.num_trafos[i] + return len(self.num_trafos) - 1, random.randrange(self.num_trafos[-1]) + + def transform_point(self, point, trafo=None): + x = (point.x - self.minx) / self.width + y = (point.y - self.miny) / self.height + if trafo is None: + trafo = self.get_random_trafo() + start, end = self.splines[trafo[0]].GetDomain() + length = end - start + seg_length = length / self.num_trafos[trafo[0]] + t = start + seg_length * trafo[1] + seg_length * x + basepoint = self.splines[trafo[0]](t) + if t + 1/50000 > end: + neighbour = self.splines[trafo[0]](t - 1/50000) + derivative = neighbour - basepoint + else: + neighbour = self.splines[trafo[0]](t + 1/50000) + derivative = basepoint - neighbour + if derivative.Mag() != 0: + basepoint.x += derivative.y / derivative.Mag() * (y - 0.5) * \ + self.thickness + basepoint.y += -derivative.x / derivative.Mag() * (y - 0.5) * \ + self.thickness + else: + print("r", end='') # isn't really executed... + self.truncate(basepoint) + return basepoint + + def truncate(self, point): + if point.x >= self.maxx: + point.x = self.maxx + if point.y >= self.maxy: + point.y = self.maxy + if point.x < self.minx: + point.x = self.minx + if point.y < self.miny: + point.y = self.miny + + def create_image_chaos(self, w, h, n): + im = [[1] * h for i in range(w)] + point = GVector((self.maxx + self.minx) / 2, + (self.maxy + self.miny) / 2, 0) + colored = 0 + for _ in range(n): + for i in range(5000): + point = self.transform_point(point) + x = (point.x - self.minx) / self.width * w + y = (point.y - self.miny) / self.height * h + x = int(x) + y = int(y) + if x == w: + x -= 1 + if y == h: + y -= 1 + im[x][h - y - 1] = 0 + + +class Data: + def __init__(self): + self.c = None + +data = Data() + +def __setup__(iterations=10): + splines = [ + Spline([ + GVector(1.597350, 3.304460, 0.000000), + GVector(1.575810, 4.123260, 0.000000), + GVector(1.313210, 5.288350, 0.000000), + GVector(1.618900, 5.329910, 0.000000), + GVector(2.889940, 5.502700, 0.000000), + GVector(2.373060, 4.381830, 0.000000), + GVector(1.662000, 4.360280, 0.000000)], + 3, [0, 0, 0, 1, 1, 1, 2, 2, 2]), + Spline([ + GVector(2.804500, 4.017350, 0.000000), + GVector(2.550500, 3.525230, 0.000000), + GVector(1.979010, 2.620360, 0.000000), + GVector(1.979010, 2.620360, 0.000000)], + 3, [0, 0, 0, 1, 1, 1]), + Spline([ + GVector(2.001670, 4.011320, 0.000000), + GVector(2.335040, 3.312830, 0.000000), + GVector(2.366800, 3.233460, 0.000000), + GVector(2.366800, 3.233460, 0.000000)], + 3, [0, 0, 0, 1, 1, 1]) + ] + data.c = Chaosgame(splines, 0.25) + +def trace_fun(frame,event,arg): + return trace_fun + +def main(iterations=10, w=1000, h=1200): + sys.settrace(trace_fun) + data.c.create_image_chaos(w, h, iterations) + +def __benchmark__(iterations=10): + main(iterations) + diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/meso/threadring.py b/graalpython/com.oracle.graal.python.benchmarks/python/meso/threadring.py index 1a94ba0a7c..fe04993d75 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/meso/threadring.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/meso/threadring.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # Copyright 2008-2010 Isaac Gouy # Copyright (c) 2013, 2014, Regents of the University of California -# Copyright (c) 2017, 2021, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # All rights reserved. # # Revised BSD license @@ -54,7 +54,7 @@ def worker(worker_id): if n > 0: n = (yield (n - 1)) else: - print(worker_id) + # print(worker_id) return diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/OWNERS.toml b/graalpython/com.oracle.graal.python.benchmarks/python/micro/OWNERS.toml new file mode 100644 index 0000000000..2391c4eadd --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "arith-binop.py arith-modulo-sized.py attribute-access.py attribute-access-polymorphic.py attribute-access-super.py attribute-bool.py boolean-logic-sized.py builtin-len.py builtin-len-tuple-sized.py call-classmethod-sized.py call-method-polymorphic.py bytecode-benchmark.py for-range.py generate-functions-sized.py c-arith-binop.py c-arith-binop2.py c-call-classmethod.py c-call-method-int-float.py c-call-method.py c-instantiate-large.py c-issubtype-monorphic.py c-issubtype-polymorphic.py c-list-iterating-obj.py c-magic-bool.py c-magic-iter.py c-member-access.py" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-binop.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-binop.py index 70129935e4..c6dffd4ed2 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-binop.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-binop.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -35,17 +35,37 @@ def docompute(num): return sum_ -def measure(num): +def measure(num, length): sum_ = 0 for run in range(num): - sum_ += docompute(10000) # 10000 + sum_ += docompute(length) # 10000 return sum_ -def __benchmark__(num=5): - return measure(num) +def __benchmark__(num=5, length=10000): + return measure(num, length) def __teardown__(): # teardown example print("arith-binop teardown") + + +def run(): + __benchmark__(num=1, length=2000) + + +def warmupIterations(): + return 10 + + +def iterations(): + return 25 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.3, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-modulo-sized.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-modulo-sized.py index 808d414388..78432f2a18 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-modulo-sized.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/arith-modulo-sized.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -51,3 +51,19 @@ def measure(num): def __benchmark__(num=50): return measure(num) + + +def run(): + __benchmark__(num=1) + + +def warmupIterations(): + return 20 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.3, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-polymorphic.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-polymorphic.py index ee24645709..04aa3dcc87 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-polymorphic.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-polymorphic.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -82,3 +82,19 @@ def measure(num): def __benchmark__(num=1000): return measure(num) + + +def run(): + __benchmark__(num=10) + + +def warmupIterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.7, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-super.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-super.py index 464aede71e..b3f109e31d 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-super.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access-super.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -84,3 +84,19 @@ def measure(num): def __benchmark__(num=5000): return measure(num) + + +def run(): + __benchmark__(10) + + +def warmupIterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.4, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access.py index 18880e5c70..3868e37609 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-access.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -50,3 +50,15 @@ def measure(num): def __benchmark__(num=5000): return measure(num) + + +def run(): + __benchmark__(num=50) + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.3, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-bool.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-bool.py index 576ca26755..d64e0077f7 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-bool.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/attribute-bool.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -75,3 +75,23 @@ def measure(num): def __benchmark__(num=3000): return measure(num) + + +def run(): + __benchmark__(num=2) + + +def warmupIterations(): + return 5 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.3, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/boolean-logic-sized.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/boolean-logic-sized.py index ab73443901..a3acddf32f 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/boolean-logic-sized.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/boolean-logic-sized.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -94,3 +94,23 @@ def measure(num): def __benchmark__(num=1000): return measure(num) + + +def run(): + return __benchmark__(num=5) + + +def warmupIterations(): + return 16 + + +def iterations(): + return 20 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.4, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len-tuple-sized.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len-tuple-sized.py index 61527b3bbc..5b9eaabf39 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len-tuple-sized.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len-tuple-sized.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -41,3 +41,23 @@ def measure(num): def __benchmark__(num): return measure(num) + + +def run(): + __benchmark__(1000000) + + +def warmupIterations(): + return 32 + + +def iterations(): + return 32 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.5, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len.py index 63f8fedd5e..1819937eee 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/builtin-len.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -43,3 +43,23 @@ def measure(num=500000000): def __benchmark__(*args): return measure(*args) + + +def run(): + __benchmark__(5000000) + + +def warmupIterations(): + return 10 + + +def iterations(): + return 20 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.9, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/bytecode-benchmark.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/bytecode-benchmark.py index ebefaeb4f5..a6d2263865 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/bytecode-benchmark.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/bytecode-benchmark.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -71,3 +71,23 @@ def __benchmark__(num=10): iter += 1 assert count == 1028, count return count + + +def run(): + __benchmark__(num=100) + + +def warmupIterations(): + return 20 + + +def iterations(): + return 30 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.7, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop.py index b8d2d28551..ed3c5fd383 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -102,6 +102,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_arith_binop_module", code) from c_arith_binop_module import FloatSubclass @@ -127,3 +133,28 @@ def measure(num): def __benchmark__(num=5): return measure(num) + + +def run(): + __benchmark__(num=2) + + +def warmupIterations(): + return 25 + + +def iterations(): + return 30 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop2.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop2.py index 2ad170d95b..390ccab9de 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop2.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-arith-binop2.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -191,6 +191,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_arith_binop_module", code) from c_arith_binop_module import FloatSubclass @@ -207,12 +213,37 @@ def docompute(num): return sum_, type(sum_) -def measure(num): +def measure(num, compute_num): sum_ = 0 for run in range(num): - sum_ += docompute(100)[0] + sum_ += docompute(compute_num)[0] return sum_ -def __benchmark__(num=5): - return measure(num) +def __benchmark__(num=5, compute_num=100): + return measure(num, compute_num) + + +def run(): + __benchmark__(num=1, compute_num=70) + + +def warmupIterations(): + return 60 + + +def iterations(): + return 15 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.4, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-classmethod.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-classmethod.py index 95554898d1..304d36c236 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-classmethod.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-classmethod.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -99,14 +99,14 @@ static PyModuleDef c_classmethod_module = { PyModuleDef_HEAD_INIT, - "c_classmethod_module", + "c_call_classmethod", "", -1, NULL, NULL, NULL, NULL, NULL }; PyMODINIT_FUNC -PyInit_c_classmethod(void) +PyInit_c_call_classmethod(void) { PyObject* m; @@ -125,8 +125,14 @@ """ -ccompile("c_classmethod", code) -from c_classmethod import NativeCustomType +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_call_classmethod", code) +from c_call_classmethod import NativeCustomType # ~igv~: function_root_count_at def count(num): @@ -143,3 +149,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=10000) + + +def warmupIterations(): + return 50 + + +def iterations(): + return 40 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.4, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-fastcall.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-fastcall.py new file mode 100644 index 0000000000..8eb7e8ebfe --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-fastcall.py @@ -0,0 +1,143 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +static PyObject* NativeCustomType_method_fastcall(PyObject *module, PyObject *const *args, Py_ssize_t nargs) { + Py_ssize_t i; + for (i=0; i < nargs; i++) { + if (!args[i]) { + PyErr_SetString(PyExc_ValueError, "arg must not be NULL"); + return NULL; + } + } + Py_RETURN_NONE; +} + +static struct PyMethodDef NativeCustomType_methods[] = { + {"method_fastcall", (PyCFunction)NativeCustomType_method_fastcall, METH_FASTCALL, NULL}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject NativeCustomType = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "NativeCustomType", + .tp_basicsize = sizeof(PyObject), + .tp_new = PyType_GenericNew, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_methods = NativeCustomType_methods +}; + +static PyModuleDef c_method_module = { + PyModuleDef_HEAD_INIT, + "c_method_module", + "", + -1, + NULL, NULL, NULL, NULL, NULL +}; + +PyMODINIT_FUNC +PyInit_c_method_module(void) +{ + PyObject* m; + + if (PyType_Ready(&NativeCustomType) < 0) + return NULL; + + m = PyModule_Create(&c_method_module); + if (m == NULL) + return NULL; + + PyModule_AddObject(m, "NativeCustomType", (PyObject *)&NativeCustomType); + return m; +} + +""" + +import sys +import os + +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_method_module", code) +from c_method_module import NativeCustomType + + +def count(num): + obj = NativeCustomType() + for i in range(num): + res = obj.method_fastcall(i, i+1, i+2) + assert res is None + return 0 + + +def measure(num): + return count(num) + + +def __benchmark__(num=1000000): + return measure(num) + + +def run(): + __benchmark__(num=3000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-int-float.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-int-float.py new file mode 100644 index 0000000000..28d37b42c2 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-int-float.py @@ -0,0 +1,116 @@ +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +PyObject* simple_method(PyObject* mod, PyObject* arg) { + return PyFloat_FromDouble(PyFloat_AsDouble(arg)); +} + +static PyMethodDef MyModuleMethods[] = { + {"as_double", simple_method, METH_O, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef c_min_method_module = { + PyModuleDef_HEAD_INIT, + "minimal_method_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_c_min_method_module(void) +{ + return PyModule_Create(&c_min_method_module); +} +""" + + +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_min_method_module", code) +from c_min_method_module import as_double + +# ~igv~: function_root_count_at +def count(num): + for i in range(num): + if 42 != as_double(42): + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) + + +def run(): + __benchmark__(num=40000) + + +def warmupIterations(): + return 25 + + +def iterations(): + return 35 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.5, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-noargs.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-noargs.py new file mode 100644 index 0000000000..1ea2d2547e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-noargs.py @@ -0,0 +1,136 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +static PyObject* NativeCustomType_method_noargs(PyObject* self, PyObject* unused) { + Py_RETURN_NONE; +} + +static struct PyMethodDef NativeCustomType_methods[] = { + {"method_noargs", (PyCFunction)NativeCustomType_method_noargs, METH_NOARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject NativeCustomType = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "NativeCustomType", + .tp_basicsize = sizeof(PyObject), + .tp_new = PyType_GenericNew, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_methods = NativeCustomType_methods +}; + +static PyModuleDef c_method_module = { + PyModuleDef_HEAD_INIT, + "c_method_module", + "", + -1, + NULL, NULL, NULL, NULL, NULL +}; + +PyMODINIT_FUNC +PyInit_c_method_module(void) +{ + PyObject* m; + + if (PyType_Ready(&NativeCustomType) < 0) + return NULL; + + m = PyModule_Create(&c_method_module); + if (m == NULL) + return NULL; + + PyModule_AddObject(m, "NativeCustomType", (PyObject *)&NativeCustomType); + return m; +} + +""" + +import sys +import os + +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_method_module", code) +from c_method_module import NativeCustomType + + +def count(num): + obj = NativeCustomType() + for _ in range(num): + res = obj.method_noargs() + assert res is None + return 0 + + +def measure(num): + return count(num) + + +def __benchmark__(num=1000000): + return measure(num) + + +def run(): + __benchmark__(num=3000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-o.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-o.py new file mode 100644 index 0000000000..cd12e09123 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-o.py @@ -0,0 +1,137 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +static PyObject* NativeCustomType_method_o(PyObject* self, PyObject* arg) { + return Py_NewRef(arg); +} + +static struct PyMethodDef NativeCustomType_methods[] = { + {"method_o", (PyCFunction)NativeCustomType_method_o, METH_O, NULL}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject NativeCustomType = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "NativeCustomType", + .tp_basicsize = sizeof(PyObject), + .tp_new = PyType_GenericNew, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_methods = NativeCustomType_methods +}; + +static PyModuleDef c_method_module = { + PyModuleDef_HEAD_INIT, + "c_method_module", + "", + -1, + NULL, NULL, NULL, NULL, NULL +}; + +PyMODINIT_FUNC +PyInit_c_method_module(void) +{ + PyObject* m; + + if (PyType_Ready(&NativeCustomType) < 0) + return NULL; + + m = PyModule_Create(&c_method_module); + if (m == NULL) + return NULL; + + PyModule_AddObject(m, "NativeCustomType", (PyObject *)&NativeCustomType); + return m; +} + +""" + +import sys +import os + +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_method_module", code) +from c_method_module import NativeCustomType + + +def count(num): + obj = NativeCustomType() + total = 0 + for i in range(num): + total += obj.method_o(i) + return total + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) + + +def run(): + __benchmark__(num=3000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-obj-args.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-obj-args.py new file mode 100644 index 0000000000..5a0a99e1c2 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-obj-args.py @@ -0,0 +1,138 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# The code below calls an API function in a loop to measure performance of C +# extensions calling into the Python C API. The _PyObject_IsFreed function is +# such an API function, and it does not do much, for 0 it's just a c-to-c call. +code = """ +#include "Python.h" +#include + +PyObject* call_method_obj_args(PyObject *module, PyObject *const *args, Py_ssize_t nargs) { + if (!_PyArg_CheckPositional("call_method_obj_args", nargs, 3, 3)) { + return NULL; + } + long n = PyLong_AsLong(args[0]); + PyObject *receiver = args[1]; + PyObject *arg = args[2]; + PyObject *result; + for (long i = 0; i < n; i++) { + result = PyObject_CallFunctionObjArgs(receiver, arg, NULL); + if (result == NULL) { + return NULL; + } + Py_DECREF(result); + } + Py_RETURN_NONE; +} + +static PyMethodDef MyModuleMethods[] = { + {"call_method_obj_args", _PyCFunction_CAST(call_method_obj_args), METH_FASTCALL, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef native_type_module = { + PyModuleDef_HEAD_INIT, + "native_type_module", + NULL, + -1, + MyModuleMethods +}; + +typedef struct { + PyObject_HEAD + vectorcallfunc vectorcall; +} NativeObject; + +static PyObject * +NativeType_vectorcall(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + Py_RETURN_NONE; +} + +static PyObject * +NativeType_new(PyTypeObject* type, PyObject* args, PyObject *kw) +{ + NativeObject *op = (NativeObject *)type->tp_alloc(type, 0); + op->vectorcall = NativeType_vectorcall; + return (PyObject *)op; +} + +static PyTypeObject NativeType = { + PyVarObject_HEAD_INIT(NULL, 0) + "NativeType", + sizeof(NativeObject), + .tp_new = NativeType_new, + .tp_call = PyVectorcall_Call, + .tp_vectorcall_offset = offsetof(NativeObject, vectorcall), + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL, +}; + +PyMODINIT_FUNC +PyInit_native_type_module(void) +{ + PyType_Ready(&NativeType); + PyObject* m = PyModule_Create(&native_type_module); + if (!m) { + return NULL; + } + PyModule_AddObject(m, "NativeType", (PyObject *)&NativeType); + return m; +} +""" + + +ccompile("native_type_module", code) +from native_type_module import NativeType, call_method_obj_args + +def count(num): + callable = NativeType() + if call_method_obj_args(num, callable, None) is not None: + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-varargs.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-varargs.py new file mode 100644 index 0000000000..1b476cfc49 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method-varargs.py @@ -0,0 +1,144 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +static PyObject* NativeCustomType_method_varargs(PyObject* self, PyObject* args) { + Py_ssize_t i; + Py_ssize_t nargs = PyTuple_GET_SIZE(args); + for (i=0; i < nargs; i++) { + if (!PyTuple_GET_ITEM(args, i)) { + PyErr_SetString(PyExc_ValueError, "arg must not be NULL"); + return NULL; + } + } + Py_RETURN_NONE; +} + +static struct PyMethodDef NativeCustomType_methods[] = { + {"method_varargs", (PyCFunction)NativeCustomType_method_varargs, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject NativeCustomType = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "NativeCustomType", + .tp_basicsize = sizeof(PyObject), + .tp_new = PyType_GenericNew, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_methods = NativeCustomType_methods +}; + +static PyModuleDef c_method_module = { + PyModuleDef_HEAD_INIT, + "c_method_module", + "", + -1, + NULL, NULL, NULL, NULL, NULL +}; + +PyMODINIT_FUNC +PyInit_c_method_module(void) +{ + PyObject* m; + + if (PyType_Ready(&NativeCustomType) < 0) + return NULL; + + m = PyModule_Create(&c_method_module); + if (m == NULL) + return NULL; + + PyModule_AddObject(m, "NativeCustomType", (PyObject *)&NativeCustomType); + return m; +} + +""" + +import sys +import os + +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_method_module", code) +from c_method_module import NativeCustomType + + +def count(num): + obj = NativeCustomType() + for i in range(num): + res = obj.method_varargs(i, i+1, i+2) + assert res is None + return 0 + + +def measure(num): + return count(num) + + +def __benchmark__(num=1000000): + return measure(num) + + +def run(): + __benchmark__(num=3000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method.py index 627ae56a8d..060ae88f47 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-call-method.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -141,12 +141,17 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_method_module", code) from c_method_module import NativeCustomType # ~igv~: function_root_count_at def count(num): - print("###### NUM: " + str(num)) obj = NativeCustomType() total = 0 for i in range(num): @@ -161,3 +166,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=3000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.7, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-dict-iterating.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-dict-iterating.py new file mode 100644 index 0000000000..fbb6dbf897 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-dict-iterating.py @@ -0,0 +1,122 @@ +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# The code below calls an API function in a loop to measure performance of C +# extensions calling into the Python C API. The _PyObject_IsFreed function is +# such an API function, and it does not do much, for 0 it's just a c-to-c call. +code = """ +#include "Python.h" +#include + +static PyObject* iterate_dict(PyObject *module, PyObject *const *args, Py_ssize_t nargs) { + if (!_PyArg_CheckPositional("iterate_dict", nargs, 2, 2)) { + return NULL; + } + long n = PyLong_AsLong(args[0]); + PyObject *arg = args[1]; + + /* variables for dict iteration */ + PyObject *key; + PyObject *value; + Py_ssize_t pos; + Py_hash_t hash; + + if (!PyDict_Check(arg)) { + PyErr_SetString(PyExc_TypeError, "arg must be a dict"); + return NULL; + } + + long long cnt = 0; + for (long i = 0; i < n; i++) { + cnt = 0; + pos = 0; + while (_PyDict_Next(arg, &pos, &key, &value, &hash)) { + if (key == NULL) { + PyErr_SetString(PyExc_ValueError, "key must not be NULL"); + return NULL; + } + if (value == NULL) { + PyErr_SetString(PyExc_ValueError, "value must not be NULL"); + return NULL; + } + cnt++; + } + } + return PyLong_FromLongLong(cnt); +} + +static PyMethodDef MyModuleMethods[] = { + {"iterate_dict", _PyCFunction_CAST(iterate_dict), METH_FASTCALL, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef iterate_dict_module = { + PyModuleDef_HEAD_INIT, + "iterate_dict_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_iterate_dict_module(void) +{ + return PyModule_Create(&iterate_dict_module); +} +""" + +ccompile("iterate_dict_module", code) +from iterate_dict_module import iterate_dict + + +def count(num): + d = {"a": 1, "b": 2, "c": 3} + result = iterate_dict(num, d) + if result != len(d): + raise RuntimeError("was: " + str(result)) + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-instantiate-large.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-instantiate-large.py index dd79157bc7..924320455a 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-instantiate-large.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-instantiate-large.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -119,6 +119,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_instantiation", code) import c_instantiation @@ -138,3 +144,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=10) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 70 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.2, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-monorphic.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-monorphic.py index a309169b60..18b3aa51e8 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-monorphic.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-monorphic.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -98,14 +98,14 @@ static PyModuleDef c_classmethod_module = { PyModuleDef_HEAD_INIT, - "c_classmethod_module", + "c_issubtype_monorphic", 0, -1, NULL, NULL, NULL, NULL, NULL }; PyMODINIT_FUNC -PyInit_c_classmethod(void) +PyInit_c_issubtype_monorphic(void) { PyObject* m; @@ -124,8 +124,14 @@ """ -ccompile("c_classmethod", code) -from c_classmethod import NativeCustomType +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_issubtype_monorphic", code) +from c_issubtype_monorphic import NativeCustomType # igv: function_root_count_at def count(num): @@ -142,3 +148,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=10000) + + +def warmupIterations(): + return 10 + + +def iterations(): + return 20 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.4, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic-forced-to-native.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic-forced-to-native.py deleted file mode 100644 index e83206e720..0000000000 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic-forced-to-native.py +++ /dev/null @@ -1,149 +0,0 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. -# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. -# -# The Universal Permissive License (UPL), Version 1.0 -# -# Subject to the condition set forth below, permission is hereby granted to any -# person obtaining a copy of this software, associated documentation and/or -# data (collectively the "Software"), free of charge and under any and all -# copyright rights in the Software, and any and all patent rights owned or -# freely licensable by each licensor hereunder covering either (i) the -# unmodified Software as contributed to or provided by such licensor, or (ii) -# the Larger Works (as defined below), to deal in both -# -# (a) the Software, and -# -# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if -# one is included with the Software each a "Larger Work" to which the Software -# is contributed by such licensors), -# -# without restriction, including without limitation the rights to copy, create -# derivative works of, display, perform, and distribute the Software and make, -# use, sell, offer for sale, import, export, have made, and have sold the -# Software and the Larger Work(s), and to sublicense the foregoing rights on -# either these or other terms. -# -# This license is subject to the following condition: -# -# The above copyright notice and either this complete permission notice or at a -# minimum a reference to the UPL must be included in all copies or substantial -# portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -code = """ -#include "Python.h" - -typedef struct { - PyObject_HEAD; -} NativeCustomObject; - -PyObject* nc_classmethod(PyObject* class, PyObject* args) { - void** somememory = (void**)calloc(sizeof(PyObject*), 2); - somememory[0] = class; - somememory[1] = PyTuple_GET_ITEM(args, 0); - int res = PyType_IsSubtype((PyTypeObject*)somememory[0], (PyTypeObject*)somememory[1]); - res += PyType_IsSubtype((PyTypeObject*)somememory[1], (PyTypeObject*)somememory[0]); - return PyLong_FromLong(res); -} - -static struct PyMethodDef nc_methods[] = { - {"customClassMethod", nc_classmethod, METH_VARARGS | METH_CLASS, ""}, - {NULL, NULL, 0, NULL} -}; - -static PyTypeObject NativeCustomType = { - PyVarObject_HEAD_INIT(NULL, 0) - "NativeCustomType.NativeCustomType", - sizeof(NativeCustomObject), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, - 0, - 0, - 0, /* tp_reserved */ - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - Py_TPFLAGS_DEFAULT, - 0, - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - nc_methods, /* tp_methods */ - NULL, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - PyType_GenericAlloc, /* tp_alloc */ - PyType_GenericNew, /* tp_new */ - PyObject_Del, /* tp_free */ -}; - -static PyModuleDef c_classmethod_module = { - PyModuleDef_HEAD_INIT, - "c_classmethod_module", - 0, - -1, - NULL, NULL, NULL, NULL, NULL -}; - -PyMODINIT_FUNC -PyInit_c_classmethod(void) -{ - PyObject* m; - - if (PyType_Ready(&NativeCustomType) < 0) - return NULL; - - m = PyModule_Create(&c_classmethod_module); - if (m == NULL) - return NULL; - - Py_INCREF(&NativeCustomType); - PyModule_AddObject(m, "NativeCustomType", (PyObject *)&NativeCustomType); - return m; -} - -""" - - -ccompile("c_classmethod", code) -from c_classmethod import NativeCustomType - -# ~igv~: function_root_count_at -def count(num): - total = 0 - classes = [str, object, type] - for i in range(num): - total += NativeCustomType.customClassMethod(classes[i % len(classes)]) - return total - - -def measure(num): - result = count(num) - return result - - -def __benchmark__(num=1000000): - return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic.py index b5a5e4266f..fe5373923c 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-issubtype-polymorphic.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -99,14 +99,14 @@ static PyModuleDef c_classmethod_module = { PyModuleDef_HEAD_INIT, - "c_classmethod_module", + "c_issubtype_polymorphic", 0, -1, NULL, NULL, NULL, NULL, NULL }; PyMODINIT_FUNC -PyInit_c_classmethod(void) +PyInit_c_issubtype_polymorphic(void) { PyObject* m; @@ -125,8 +125,14 @@ """ -ccompile("c_classmethod", code) -from c_classmethod import NativeCustomType +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + +ccompile("c_issubtype_polymorphic", code) +from c_issubtype_polymorphic import NativeCustomType class X(): pass @@ -147,3 +153,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=10000) + + +def warmupIterations(): + return 60 + + +def iterations(): + return 25 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.2, + "upper-threshold": 0.4, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-list-iterating-obj.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-list-iterating-obj.py index 77c9004c07..0d022a4838 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-list-iterating-obj.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-list-iterating-obj.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -180,6 +180,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_list_iterating_obj_module", code) import c_list_iterating_obj_module @@ -197,3 +203,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=40000) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 50 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.1, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-bool.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-bool.py index b706c55c0b..d1ad84d8ec 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-bool.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-bool.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -180,6 +180,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_magic_bool_module", code) import c_magic_bool_module @@ -203,3 +209,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=50000) + + +def warmupIterations(): + return 5 + + +def iterations(): + return 45 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.4, + "upper-threshold": 0.6, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-iter.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-iter.py index 9ca3dbd0e0..17ffdbe7da 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-iter.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-magic-iter.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -237,6 +237,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_custom_iterable_module", code) import c_custom_iterable_module @@ -259,3 +265,28 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + + +def run(): + __benchmark__(num=10000) + + +def warmupIterations(): + return 40 + + +def iterations(): + return 30 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.3, + "upper-threshold": 0.5, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-member-access.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-member-access.py index 0c01c2a3e7..b8f40d5cfd 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-member-access.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-member-access.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -134,6 +134,12 @@ """ +import sys +import os +# Add benchmark directory to path to allow import of harness.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from harness import ccompile + ccompile("c_member_access_module", code) import c_member_access_module @@ -157,3 +163,28 @@ def measure(num): def __benchmark__(num=50000): return measure(num) + + +def run(): + __benchmark__(num=5) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 90 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.1, + } + + +def dependencies(): + # Required to run `ccompile` + return ["harness.py", "tests/__init__.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-to-c.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-to-c.py new file mode 100644 index 0000000000..d95986136c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-to-c.py @@ -0,0 +1,90 @@ +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# The code below calls an API function in a loop to measure performance of C +# extensions calling into the Python C API. The _PyObject_IsFreed function is +# such an API function, and it does not do much, for 0 it's just a c-to-c call. +code = """ +#include "Python.h" + +PyObject* simple_to_c(PyObject* mod, PyObject* arg) { + long upper = PyLong_AsLong(arg); + for (long i = 0; i < upper; i++) { + _PyObject_IsFreed((PyObject *)0L); + } + Py_RETURN_NONE; +} + +static PyMethodDef MyModuleMethods[] = { + {"simple_to_c", simple_to_c, METH_O, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef simple_to_c_module = { + PyModuleDef_HEAD_INIT, + "simple_to_c_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_simple_to_c_module(void) +{ + return PyModule_Create(&simple_to_c_module); +} +""" + + +ccompile("simple_to_c_module", code) +from simple_to_c_module import simple_to_c + +def count(num): + if simple_to_c(num) is not None: + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-builtin-function.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-builtin-function.py new file mode 100644 index 0000000000..d3975b3f16 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-builtin-function.py @@ -0,0 +1,107 @@ +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +PyObject* simple_upcall(PyObject* mod, PyObject* args) { + PyObject *func = PyTuple_GetItem(args, 0); + PyObject *self = PyTuple_GetItem(args, 1); + long upper = PyLong_AsLong(PyTuple_GetItem(args, 2)); + if (!PyCFunction_Check(func)) { + PyErr_SetString(PyExc_TypeError, "expected a builtin method"); + return NULL; + } +#ifdef GRAALVM_PYTHON + PyMethodDef *ml = GraalPyCFunction_GetMethodDef(func); +#else + PyCFunctionObject *cfunc = (PyCFunctionObject*)func; + PyMethodDef *ml = cfunc->m_ml; +#endif + PyCFunction ml_meth = ml->ml_meth; + + for (long i = 0; i < upper; i++) { + PyObject *res = ml_meth(self, NULL); + Py_XDECREF(res); + if (!res) { + return NULL; + } + } + Py_RETURN_NONE; +} + +static PyMethodDef MyModuleMethods[] = { + {"simple_upcall", simple_upcall, METH_O, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef simple_upcall_module = { + PyModuleDef_HEAD_INIT, + "simple_upcall_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_simple_upcall_module(void) +{ + return PyModule_Create(&simple_upcall_module); +} +""" + + +ccompile("simple_upcall_module", code) +from simple_upcall_module import simple_upcall + +def count(num): + lst = [] + my_tuple = (lst.clear, lst, num) + if simple_upcall(my_tuple) is not None: + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-slot.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-slot.py new file mode 100644 index 0000000000..eb137d4451 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall-slot.py @@ -0,0 +1,98 @@ +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +PyObject* simple_upcall(PyObject* mod, PyObject* args) { + PyObject *self = PyTuple_GetItem(args, 0); + long upper = PyLong_AsLong(PyTuple_GetItem(args, 1)); + if (!PyList_Check(self)) { + PyErr_Format(PyExc_TypeError, "expected list, not '%.200s'", Py_TYPE(self)->tp_name); + return NULL; + } + lenfunc f = PyList_Type.tp_as_sequence->sq_length; + for (long i = 0; i < upper; i++) { + Py_ssize_t len = f(self); + if (len < 0) { + return NULL; + } + } + Py_RETURN_NONE; +} + +static PyMethodDef MyModuleMethods[] = { + {"simple_upcall", simple_upcall, METH_O, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef simple_upcall_module = { + PyModuleDef_HEAD_INIT, + "simple_upcall_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_simple_upcall_module(void) +{ + return PyModule_Create(&simple_upcall_module); +} +""" + + +ccompile("simple_upcall_module", code) +from simple_upcall_module import simple_upcall + +def count(num): + lst = [] + my_tuple = (lst, num) + if simple_upcall(my_tuple) is not None: + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall.py new file mode 100644 index 0000000000..f79343a7c3 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/c-upcall.py @@ -0,0 +1,87 @@ +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +code = """ +#include "Python.h" + +PyObject* simple_upcall(PyObject* mod, PyObject* arg) { + long upper = PyLong_AsLong(arg); + for (long i = 0; i < upper; i++) { + PyThread_get_thread_ident(); + } + Py_RETURN_NONE; +} + +static PyMethodDef MyModuleMethods[] = { + {"simple_upcall", simple_upcall, METH_O, NULL}, + {NULL, NULL, 0, NULL} // Sentinel +}; + +static PyModuleDef simple_upcall_module = { + PyModuleDef_HEAD_INIT, + "simple_upcall_module", + NULL, + -1, + MyModuleMethods +}; + +PyMODINIT_FUNC +PyInit_simple_upcall_module(void) +{ + return PyModule_Create(&simple_upcall_module); +} +""" + + +ccompile("simple_upcall_module", code) +from simple_upcall_module import simple_upcall + +def count(num): + if simple_upcall(num) is not None: + raise RuntimeError() + return 0 + + +def measure(num): + result = count(num) + return result + + +def __benchmark__(num=1000000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-classmethod-sized.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-classmethod-sized.py index 8d15a620e8..fc0b85e7c7 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-classmethod-sized.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-classmethod-sized.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -58,3 +58,22 @@ def measure(num): def __benchmark__(num=1000000): return measure(num) + +def run(): + __benchmark__(num=1000000) + + +def warmupIterations(): + return 8 + + +def iterations(): + return 30 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.4, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-method-polymorphic.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-method-polymorphic.py index 87c396d0f0..4b0350e0dc 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-method-polymorphic.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/call-method-polymorphic.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -92,3 +92,23 @@ def measure(num): def __benchmark__(num=1000): return measure(num) + + +def run(): + __benchmark__(num=3) + + +def warmupIterations(): + return 16 + + +def iterations(): + return 24 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 0.3, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/for-range.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/for-range.py index 032ac564fe..6ac925a0bc 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/for-range.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/for-range.py @@ -1,4 +1,4 @@ -# Copyright (c) 2017, 2024, Oracle and/or its affiliates. +# Copyright (c) 2017, 2025, Oracle and/or its affiliates. # Copyright (c) 2013, Regents of the University of California # # All rights reserved. @@ -48,3 +48,19 @@ def measure(num): def __benchmark__(num=50000): return measure(num) + + +def run(): + __benchmark__(50) + + +def warmupIterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.8, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/generate-functions-sized.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/generate-functions-sized.py index 41ffdcadd3..b43fa4319f 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/generate-functions-sized.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/generate-functions-sized.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -59,3 +59,18 @@ def measure(num): def __benchmark__(num=10000): return measure(num) + +def run(): + __benchmark__(num=400000) + + +def warmupIterations(): + return 25 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.1, + "upper-threshold": 0.8, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/jsonrpc-pipe.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/jsonrpc-pipe.py new file mode 100644 index 0000000000..f3762c5466 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/jsonrpc-pipe.py @@ -0,0 +1,455 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import annotations + +import argparse +import io +import json +import os +import re +import subprocess +import sys +import time + + +EMAIL_RE = re.compile(r"\s+") +NON_DIGIT_RE = re.compile(r"\D+") +_STATE = None + + +class Endpoint: + def __init__(self, mode, reader, writer, closeables=()): + self.mode = mode + self.reader = reader + self.writer = writer + self.closeables = closeables + + def write_message(self, message): + line = json.dumps(message, separators=(",", ":")) + if self.mode == "text": + self.writer.write(line) + self.writer.write("\n") + self.writer.flush() + return + payload = (line + "\n").encode("utf-8") + if self.mode == "buffer": + self.writer.write(payload) + self.writer.flush() + return + write_all(self.writer, payload) + + def read_message(self): + if self.mode == "text": + line = self.reader.readline() + else: + data = self.reader.readline() + line = data.decode("utf-8") if data else "" + if not line: + raise EOFError("unexpected EOF while reading line") + return json.loads(line) + + def close(self): + streams = self.closeables if self.closeables else (self.reader, self.writer) + for stream in streams: + if hasattr(stream, "close"): + try: + stream.close() + except OSError: + pass + + +class FDLineReader: + def __init__(self, fd): + self.fd = fd + self.pending = bytearray() + + def readline(self): + while True: + newline = self.pending.find(b"\n") + if newline >= 0: + line = bytes(self.pending[: newline + 1]) + del self.pending[: newline + 1] + return line + chunk = os.read(self.fd, 4096) + if not chunk: + if not self.pending: + return b"" + line = bytes(self.pending) + self.pending.clear() + return line + self.pending.extend(chunk) + + +class State: + def __init__(self, roundtrips, client_io, worker_io, workload, payload_bytes, batch_size): + self.roundtrips = roundtrips + self.client_io = client_io + self.worker_io = worker_io + self.workload = workload + self.payload_bytes = payload_bytes + self.batch_size = batch_size + self.next_request_id = 1 + self.process = None + self.endpoint = None + + +def write_all(fd, data): + view = memoryview(data) + while view: + written = os.write(fd, view) + view = view[written:] + + +def create_text_endpoint(read_raw, write_raw): + reader_buffer = io.BufferedReader(read_raw, buffer_size=8192) + writer_buffer = io.BufferedWriter(write_raw, buffer_size=8192) + reader = io.TextIOWrapper(reader_buffer, encoding="utf-8", newline=None) + writer = io.TextIOWrapper(writer_buffer, encoding="utf-8", newline="\n", line_buffering=False, write_through=False) + return Endpoint("text", reader, writer) + + +def create_buffer_endpoint(read_raw, write_raw): + reader = io.BufferedReader(read_raw, buffer_size=8192) + writer = io.BufferedWriter(write_raw, buffer_size=8192) + return Endpoint("buffer", reader, writer) + + +def create_fd_endpoint(read_fd, write_fd, closeables=()): + return Endpoint("fd", FDLineReader(read_fd), write_fd, closeables) + + +def create_parent_endpoint(process, mode): + if mode == "text": + return create_text_endpoint(process.stdout, process.stdin) + if mode == "buffer": + return create_buffer_endpoint(process.stdout, process.stdin) + return create_fd_endpoint(process.stdout.fileno(), process.stdin.fileno(), (process.stdout, process.stdin)) + + +def create_worker_endpoint(mode): + if mode == "text": + return Endpoint("text", sys.stdin, sys.stdout) + if mode == "buffer": + return Endpoint("buffer", sys.stdin.buffer, sys.stdout.buffer) + return create_fd_endpoint(0, 1) + + +def normalize_email(value): + return EMAIL_RE.sub("", value.strip().lower()) + + +def normalize_phone(value): + digits = NON_DIGIT_RE.sub("", value) + if digits.startswith("00"): + digits = digits[2:] + return digits + + +def mask_email(value): + name, _, domain = value.partition("@") + if not domain: + return "***" + return "%s***@%s" % (name[:1], domain) + + +def mask_phone(value): + if len(value) <= 4: + return "*" * len(value) + return "*" * (len(value) - 4) + value[-4:] + + +def mask_row(row): + email = normalize_email(str(row.get("email", ""))) + phone = normalize_phone(str(row.get("phone", ""))) + return { + "email_normalized": email, + "phone_normalized": phone, + "email_masked": mask_email(email) if email else None, + "phone_masked": mask_phone(phone) if phone else None, + "region": str(row.get("region", "")).upper(), + "source": str(row.get("source", "")).lower(), + } + + +def make_echo_payload(payload_bytes): + if payload_bytes <= 0: + return "" + unit = "payload-" + return (unit * ((payload_bytes // len(unit)) + 1))[:payload_bytes] + + +def make_mask_row(index, payload_bytes): + suffix = make_echo_payload(max(payload_bytes, 8)) + return { + "email": " User%s.%s@Example.COM " % (index, suffix), + "phone": "+49 (170) %04d-%s" % (index, suffix[:8]), + "region": "eu", + "source": "microbench", + } + + +def build_request(kind, request_id, payload_bytes, batch_size): + if kind == "health": + method = "health" + params = {} + elif kind == "echo": + method = "echo" + params = {"payload": make_echo_payload(payload_bytes)} + elif kind == "mask": + method = "mask" + params = make_mask_row(request_id, payload_bytes) + elif kind == "mask_batch": + method = "mask_batch" + params = {"rows": [make_mask_row(request_id + i, payload_bytes) for i in range(batch_size)]} + else: + raise AssertionError("unsupported request kind: %s" % kind) + return {"jsonrpc": "2.0", "id": request_id, "method": method, "params": params} + + +def handle_request(message): + request_id = message.get("id") + method = message.get("method") + params = message.get("params", {}) + if method == "health": + result = {"ok": True, "worker": "jsonrpc-pipe", "protocol": "json-rpc-2.0-ndjson"} + elif method == "echo": + payload = str(dict(params).get("payload", "")) + result = {"ok": True, "echo": payload, "size": len(payload)} + elif method == "mask": + result = {"ok": True, "normalized": mask_row(dict(params))} + elif method == "mask_batch": + rows = [mask_row(dict(row)) for row in dict(params).get("rows", [])] + result = {"ok": True, "normalized": rows, "count": len(rows)} + else: + return {"jsonrpc": "2.0", "id": request_id, "error": {"code": -32601, "message": "method not found"}} + return {"jsonrpc": "2.0", "id": request_id, "result": result} + + +def validate_response(request, response, kind, payload_bytes, batch_size): + if response.get("id") != request["id"]: + raise AssertionError("mismatched response id") + if "error" in response: + raise AssertionError("worker returned error: %s" % (response["error"],)) + result = response.get("result") + if not isinstance(result, dict) or not result.get("ok"): + raise AssertionError("unexpected response payload: %s" % (response,)) + if kind == "echo": + if result.get("echo") != make_echo_payload(payload_bytes): + raise AssertionError("echo payload mismatch") + elif kind == "mask": + expected = mask_row(make_mask_row(int(request["id"]), payload_bytes)) + if result.get("normalized") != expected: + raise AssertionError("mask result mismatch") + elif kind == "mask_batch": + expected_rows = [mask_row(make_mask_row(int(request["id"]) + i, payload_bytes)) for i in range(batch_size)] + if result.get("count") != batch_size or result.get("normalized") != expected_rows: + raise AssertionError("mask_batch result mismatch") + + +def run_roundtrips(state): + completed = 0 + for _ in range(state.roundtrips): + request = build_request(state.workload, state.next_request_id, state.payload_bytes, state.batch_size) + state.next_request_id += 1 + state.endpoint.write_message(request) + response = state.endpoint.read_message() + validate_response(request, response, state.workload, state.payload_bytes, state.batch_size) + completed += 1 + return completed + + +def parse_int(value): + if isinstance(value, int): + return value + return int(str(value).replace("_", "")) + + +def get_subprocess_launcher_args(): + orig_argv = getattr(sys, "orig_argv", None) + if not orig_argv: + return [sys.executable] + + main_argv0 = sys.argv[0] + for i, arg in enumerate(orig_argv[1:], start=1): + if arg == main_argv0: + return [sys.executable, *orig_argv[1:i]] + + launcher_args = [sys.executable] + i = 1 + while i < len(orig_argv): + arg = orig_argv[i] + if not arg.startswith("-"): + break + launcher_args.append(arg) + if arg == "-X" and i + 1 < len(orig_argv): + i += 1 + launcher_args.append(orig_argv[i]) + i += 1 + return launcher_args + + +def __process_args__(roundtrips=500, client_io="text", worker_io="text", workload="mask", payload_bytes=64, batch_size=8): + return [ + parse_int(roundtrips), + str(client_io), + str(worker_io), + str(workload), + parse_int(payload_bytes), + parse_int(batch_size), + ] + + +def __setup__(roundtrips=500, client_io="text", worker_io="text", workload="mask", payload_bytes=64, batch_size=8): + global _STATE + __teardown__() + state = State(roundtrips, client_io, worker_io, workload, payload_bytes, batch_size) + command = [ + *get_subprocess_launcher_args(), + __file__, + "--worker", + "--worker-io=%s" % worker_io, + ] + process = subprocess.Popen( + command, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + bufsize=0, + ) + state.process = process + state.endpoint = create_parent_endpoint(process, client_io) + _STATE = state + + +def __benchmark__(roundtrips=500, client_io="text", worker_io="text", workload="mask", payload_bytes=64, batch_size=8): + if _STATE is None: + __setup__(roundtrips, client_io, worker_io, workload, payload_bytes, batch_size) + return run_roundtrips(_STATE) + + +def __teardown__(): + global _STATE + state = _STATE + _STATE = None + if state is None: + return + try: + if state.endpoint is not None: + state.endpoint.close() + finally: + if state.process is not None: + stderr = b"" + try: + stderr = state.process.stderr.read() if state.process.stderr is not None else b"" + except OSError: + pass + return_code = state.process.wait() + if return_code != 0: + raise RuntimeError("worker exited with status %d: %s" % (return_code, stderr.decode("utf-8", errors="replace"))) + + +def run_worker(worker_io): + endpoint = create_worker_endpoint(worker_io) + try: + while True: + try: + request = endpoint.read_message() + except EOFError: + return 0 + endpoint.write_message(handle_request(request)) + finally: + endpoint.close() + + +def run_direct(roundtrips, client_io, worker_io, workload, payload_bytes, batch_size): + start = time.perf_counter() + __setup__(roundtrips, client_io, worker_io, workload, payload_bytes, batch_size) + try: + completed = __benchmark__(roundtrips, client_io, worker_io, workload, payload_bytes, batch_size) + finally: + __teardown__() + wall = time.perf_counter() - start + print("roundtrips=%d" % completed) + print("wall_s=%s" % wall) + print("throughput_ops_s=%s" % (completed / wall if wall else 0.0)) + return 0 + + +def main(argv=None): + parser = argparse.ArgumentParser(description="Strict JSON-RPC-like pipe roundtrip microbenchmark.") + parser.add_argument("--worker", action="store_true") + parser.add_argument("--worker-io", choices=("text", "buffer", "fd"), default="text") + parser.add_argument("--roundtrips", type=parse_int, default=500) + parser.add_argument("--client-io", choices=("text", "buffer", "fd"), default="text") + parser.add_argument("--workload", choices=("health", "echo", "mask", "mask_batch"), default="mask") + parser.add_argument("--payload-bytes", type=parse_int, default=64) + parser.add_argument("--batch-size", type=parse_int, default=8) + args = parser.parse_args(argv) + if args.worker: + return run_worker(args.worker_io) + return run_direct(args.roundtrips, args.client_io, args.worker_io, args.workload, args.payload_bytes, args.batch_size) + + +def run(): + __setup__() + try: + __benchmark__() + finally: + __teardown__() + + +def warmupIterations(): + return 5 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0, + "upper-threshold": 0.3, + } + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/list-comp2.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/list-comp2.py new file mode 100644 index 0000000000..e6048d9b53 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/list-comp2.py @@ -0,0 +1,39 @@ +# Copyright (c) 2017, 2026, Oracle and/or its affiliates. +# Copyright (c) 2013, Regents of the University of California +# +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, are +# permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, this list of +# conditions and the following disclaimer in the documentation and/or other materials provided +# with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +# OF THE POSSIBILITY OF SUCH DAMAGE. +# micro benchmark: list comprehension + + +def make_lists(num): + for i in range(num): + ll = [i for i in range(10)] + + return ll[-1] + + +def measure(num): + return make_lists(num) # 50000 + + +def __benchmark__(num=5000): + return measure(num) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/magic-iter.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/magic-iter.py index 30d5aae8de..fd8bb52956 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/magic-iter.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/magic-iter.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -38,7 +38,18 @@ # SOFTWARE. class CustomIterator: + # Even though this is worse for our generated code, it is increasingly + # common, because the typing PEP explicitly has an example like this: + # https://peps.python.org/pep-0526/#class-and-instance-variable-annotations + # + # While that is a historical document, it is a) still widely referenced and + # b) at the time of writing this comment latest spec still has a similar + # example where a variable is initialized with a default on the class level + # and the __init__ method only conditionally overrides the default *and + # otherwise keeps it on the class* making self.FOO accesses polymorphic: + # https://typing.python.org/en/latest/spec/class-compat.html#classvar pos = 0 + def __init__(self, obj): self.__obj = obj @@ -70,7 +81,7 @@ def count(num): val0 = next(it) val1 = next(it) val2 = next(it) - + return (val0, val1, val2) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-arith.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-arith.py new file mode 100644 index 0000000000..e952720a99 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-arith.py @@ -0,0 +1,61 @@ +# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +def measure(i,j,q): + while i < j: + i = i + 2 + i = i - 1 + i = i + 1 + i = i - 1 + i = i + 1 + i = i - 1 + i = i + 1 + i = i - 1 + i = i + 1 + i = i - 1 + i = i + 2 + i = i - 2 + i = i + 1 + i = i - 1 + i = i + 1 + i = i - 2 + i = i + 2 + return i + +def __benchmark__(*args): + return measure(0, 10000000, 0) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-attribute.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-attribute.py new file mode 100644 index 0000000000..c07d98ca1b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-attribute.py @@ -0,0 +1,50 @@ +# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +class T(): + def __init__(self): + self.foo = 1 + +def measure(i,j): + o = T() + while i < j: + i = i + o.foo + return i + +def __benchmark__(*args): + return measure(0, 100000000) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-if.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-if.py new file mode 100644 index 0000000000..576514a1de --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-if.py @@ -0,0 +1,47 @@ +# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +def measure(i,j): + while i < j: + i = i + 1 + if i & 1 != 0: + i = i + 2 + return i + +def __benchmark__(*args): + return measure(0, 50000000) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-loop.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-loop.py new file mode 100644 index 0000000000..1d7a3b148d --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-loop.py @@ -0,0 +1,45 @@ +# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +def measure(i,j): + while i < j: + i = i + 2 + return i + +def __benchmark__(*args): + return measure(0, 100000000) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-property.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-property.py new file mode 100644 index 0000000000..682a30074c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/nano-property.py @@ -0,0 +1,51 @@ +# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +class T(): + @property + def foo(self): + return 1 + +def measure(i, j): + o = T() + while i < j: + i = i + o.foo + return i + +def __benchmark__(*args): + return measure(0, 100000000) diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/LICENSE.txt b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/LICENSE.txt new file mode 100644 index 0000000000..74b2da5e3f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/LICENSE.txt @@ -0,0 +1,30 @@ +Copyright (c) 2005-2025, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/OWNERS.toml b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/OWNERS.toml new file mode 100644 index 0000000000..34cb11f338 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "*" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/README.md b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/README.md new file mode 100644 index 0000000000..0093444ebd --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/README.md @@ -0,0 +1,155 @@ +# Numpy benchmark port process for benchmarking with the PolyBench harness + +## Brief explanation + +These PolyBench benchmarks have been manually generated for the file `bench_core.py` +that was copied from the `numpy` repository. +Each benchmark file maps 1:1 to a `test_*` method of a `Benchmark` extending class +inside `bench_core.py` and the files are named following the pattern of `--.py` +- e.g. the PolyBench benchmark file `bench_core.Core.time_array_1.py` corresponds to +the `time_array_1` method of the `Core` class which is defined in the `bench_core.py` file. + +If required, the imported set of benchmarks could be expanded to other numpy benchmarks analogously. + +## Version information + +Version: 1.26.4 +Source repository: https://github.com/numpy/numpy + +The version was chosen to align with the one used in `graalpython/mx.graalpython/mx_graalpython_python_benchmarks.py::NumPySuite`. + +## Files sourced from the numpy project + +### bench_core.py +Original file path: numpy/benchmarks/benchmarks/bench_core.py +Changes made to the original file, as reported by the `diff` tool: +``` +1,2c1,2 +< from .common import Benchmark +< +--- +> import sys +> import os +3a4,5 +> sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +> from common import Benchmark +4a7,8 +> # Ensure we have numpy version info in the logs +> print(f"Using numpy version '{np.__version__}'") +``` + +### common.py +Original file path: numpy/benchmarks/benchmarks/common.py +No modifications made. + +### License.txt +The BSD 3-clause license copied from the numpy repository. + +## Original files necessary for benchmarking with the PolyBench harness + +### `--.py` files +These are new files that do not have a corresponding match in the numpy repository. +They are thus licensed under the Oracle UPL license used elsewhere in this repository. +These files are generated to conform to the expectations of the PolyBench harness. +These files were generated with the help of a generative AI model using the following pattern: +``` +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = + = None + + +def setup(): + from import + global + = () + .setup() + + +def __benchmark__(): + # Original workload + .() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return [".py", "common.py"] + +``` +Where: +* `` is a global variable that stores the instance of the benchmark class. +* `` is the name of the benchmark file (without the extension, e.g. `bench_core`). +* `` is the benchmark class (e.g. `Core`). +* `` is the benchmark method (e.g. `time_array_1`). +* `` is a number tweaked to ensure a workload long enough to minimize noise. +The value was initially set by the AI model and subsequently tweaked by hand. +The value was tweaked so that the benchmark executes somewhere in the range between 10ms and 1s. + +This template is not exhaustive and is provided for the purpose of facilitating maintenance. +There are multiple edge-cases one has to consider when generating a benchmark file: +* The benchmark class might not implement the `setup` method. +* The benchmark method might require arguments to be passed. +In such cases, the values were chosen from the `params` field of the benchmark class and stored +as global constants next to the `LOOP_COUNT` constant. diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_arange_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_arange_100.py new file mode 100644 index 0000000000..4e35d7a9df --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_arange_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_arange_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_1.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_1.py new file mode 100644 index 0000000000..c194635129 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_1.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1_000_000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_1() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_empty.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_empty.py new file mode 100644 index 0000000000..d45537b0e7 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_empty.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1_000_000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_empty() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float64_l1000.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float64_l1000.py new file mode 100644 index 0000000000..921ac4d649 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float64_l1000.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_float64_l1000() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000.py new file mode 100644 index 0000000000..7156a80e3f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_float_l1000() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000_dtype.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000_dtype.py new file mode 100644 index 0000000000..2d6b8b510b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_float_l1000_dtype.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_float_l1000_dtype() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_int_l1000.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_int_l1000.py new file mode 100644 index 0000000000..7d1335ea9b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_int_l1000.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_int_l1000() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l.py new file mode 100644 index 0000000000..038ce95126 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_l() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l1.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l1.py new file mode 100644 index 0000000000..7292875851 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l1.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_l1() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l100.py new file mode 100644 index 0000000000..43c4585ddb --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_l100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l_view.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l_view.py new file mode 100644 index 0000000000..1a75b55ac8 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_array_l_view.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_array_l_view() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast.py new file mode 100644 index 0000000000..b50cee1ca1 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_can_cast() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast_same_kind.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast_same_kind.py new file mode 100644 index 0000000000..ae28277ca6 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_can_cast_same_kind.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_can_cast_same_kind() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diag_l100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diag_l100.py new file mode 100644 index 0000000000..dde6f3c72c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diag_l100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_diag_l100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l100.py new file mode 100644 index 0000000000..f7652a760f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_diagflat_l100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l50_l50.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l50_l50.py new file mode 100644 index 0000000000..ae08e0539e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_diagflat_l50_l50.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_diagflat_l50_l50() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_dstack_l.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_dstack_l.py new file mode 100644 index 0000000000..3675b67682 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_dstack_l.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_dstack_l() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_100.py new file mode 100644 index 0000000000..4ebda680df --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_empty_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_like.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_like.py new file mode 100644 index 0000000000..48de92709a --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_empty_like.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_empty_like() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_100.py new file mode 100644 index 0000000000..5487c7a40a --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_eye_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_3000.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_3000.py new file mode 100644 index 0000000000..2b5448c797 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_eye_3000.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_eye_3000() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_hstack_l.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_hstack_l.py new file mode 100644 index 0000000000..45023a6837 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_hstack_l.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_hstack_l() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_100.py new file mode 100644 index 0000000000..ba1b5d0b99 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_identity_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_3000.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_3000.py new file mode 100644 index 0000000000..55ae152590 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_identity_3000.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_identity_3000() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_ones_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_ones_100.py new file mode 100644 index 0000000000..b367291978 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_ones_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_ones_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_indices_500.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_indices_500.py new file mode 100644 index 0000000000..5548196c32 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_indices_500.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_tril_indices_500() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_l10x10.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_l10x10.py new file mode 100644 index 0000000000..35efb90e1f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_tril_l10x10.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_tril_l10x10() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_indices_500.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_indices_500.py new file mode 100644 index 0000000000..4cf56bbe5c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_indices_500.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_triu_indices_500() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_l10x10.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_l10x10.py new file mode 100644 index 0000000000..9cbc8aa209 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_triu_l10x10.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_triu_l10x10() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_vstack_l.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_vstack_l.py new file mode 100644 index 0000000000..727d612ad1 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_vstack_l.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_vstack_l() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_zeros_100.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_zeros_100.py new file mode 100644 index 0000000000..dc8bdfbcc4 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Core.time_zeros_100.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100000 +_core = None + + +def setup(): + from bench_core import Core + global _core + _core = Core() + _core.setup() + + +def __benchmark__(): + # Original workload + _core.time_zeros_100() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_convolve.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_convolve.py new file mode 100644 index 0000000000..a56bbf974e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_convolve.py @@ -0,0 +1,87 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +SIZE1 = int(1e5) +SIZE2 = int(1e4) +MODE = 'valid' + +LOOP_COUNT = 1 +_corrconv = None + + +def setup(): + from bench_core import CorrConv + global _corrconv + _corrconv = CorrConv() + _corrconv.setup(SIZE1, SIZE2, MODE) + + +def __benchmark__(): + # Original workload + _corrconv.time_convolve(SIZE1, SIZE2, MODE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_correlate.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_correlate.py new file mode 100644 index 0000000000..60b76b7d3c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CorrConv.time_correlate.py @@ -0,0 +1,87 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +SIZE1 = int(1e5) +SIZE2 = int(1e4) +MODE = 'valid' + +LOOP_COUNT = 1 +_corrconv = None + + +def setup(): + from bench_core import CorrConv + global _corrconv + _corrconv = CorrConv() + _corrconv.setup(SIZE1, SIZE2, MODE) + + +def __benchmark__(): + # Original workload + _corrconv.time_correlate(SIZE1, SIZE2, MODE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero.py new file mode 100644 index 0000000000..a111364397 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero.py @@ -0,0 +1,87 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +NUMAXES = 3 +SIZE = 1_000_000 +DTYPE = bool + +LOOP_COUNT = 1000 +_countnonzero = None + + +def setup(): + from bench_core import CountNonzero + global _countnonzero + _countnonzero = CountNonzero() + _countnonzero.setup(NUMAXES, SIZE, DTYPE) + + +def __benchmark__(): + # Original workload + _countnonzero.time_count_nonzero(NUMAXES, SIZE, DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_axis.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_axis.py new file mode 100644 index 0000000000..a840160d81 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_axis.py @@ -0,0 +1,87 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +NUMAXES = 3 +SIZE = 1_000_000 +DTYPE = bool + +LOOP_COUNT = 10 +_countnonzero = None + + +def setup(): + from bench_core import CountNonzero + global _countnonzero + _countnonzero = CountNonzero() + _countnonzero.setup(NUMAXES, SIZE, DTYPE) + + +def __benchmark__(): + # Original workload + _countnonzero.time_count_nonzero_axis(NUMAXES, SIZE, DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_multi_axis.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_multi_axis.py new file mode 100644 index 0000000000..8b59ef4f42 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.CountNonzero.time_count_nonzero_multi_axis.py @@ -0,0 +1,87 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +NUMAXES = 3 +SIZE = 1_000_000 +DTYPE = bool + +LOOP_COUNT = 10 +_countnonzero = None + + +def setup(): + from bench_core import CountNonzero + global _countnonzero + _countnonzero = CountNonzero() + _countnonzero.setup(NUMAXES, SIZE, DTYPE) + + +def __benchmark__(): + # Original workload + _countnonzero.time_count_nonzero_multi_axis(NUMAXES, SIZE, DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Indices.time_indices.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Indices.time_indices.py new file mode 100644 index 0000000000..d5370a4a4c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Indices.time_indices.py @@ -0,0 +1,82 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_indices = None + + +def setup(): + from bench_core import Indices + global _indices + _indices = Indices() + + +def __benchmark__(): + # Original workload + _indices.time_indices() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits.py new file mode 100644 index 0000000000..197bf75fb3 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits.py @@ -0,0 +1,85 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = bool + +LOOP_COUNT = 100000 +_packbits = None + + +def setup(): + from bench_core import PackBits + global _packbits + _packbits = PackBits() + _packbits.setup(DTYPE) + + +def __benchmark__(): + # Original workload + _packbits.time_packbits(DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis0.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis0.py new file mode 100644 index 0000000000..bf305b0513 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis0.py @@ -0,0 +1,85 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = bool + +LOOP_COUNT = 100 +_packbits = None + + +def setup(): + from bench_core import PackBits + global _packbits + _packbits = PackBits() + _packbits.setup(DTYPE) + + +def __benchmark__(): + # Original workload + _packbits.time_packbits_axis0(DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis1.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis1.py new file mode 100644 index 0000000000..453dc0881b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_axis1.py @@ -0,0 +1,85 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = bool + +LOOP_COUNT = 10000 +_packbits = None + + +def setup(): + from bench_core import PackBits + global _packbits + _packbits = PackBits() + _packbits.setup(DTYPE) + + +def __benchmark__(): + # Original workload + _packbits.time_packbits_axis1(DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_little.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_little.py new file mode 100644 index 0000000000..c160ce0732 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.PackBits.time_packbits_little.py @@ -0,0 +1,85 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = bool + +LOOP_COUNT = 100000 +_packbits = None + + +def setup(): + from bench_core import PackBits + global _packbits + _packbits = PackBits() + _packbits.setup(DTYPE) + + +def __benchmark__(): + # Original workload + _packbits.time_packbits_little(DTYPE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_max.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_max.py new file mode 100644 index 0000000000..947977beae --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_max.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 10000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_max(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_mean.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_mean.py new file mode 100644 index 0000000000..b30c1a833c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_mean.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 10000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_mean(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_min.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_min.py new file mode 100644 index 0000000000..42daeed0ae --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_min.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 10000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_min(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_prod.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_prod.py new file mode 100644 index 0000000000..011bc5df46 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_prod.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 10000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_prod(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_std.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_std.py new file mode 100644 index 0000000000..12450de327 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_std.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 1000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_std(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_sum.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_sum.py new file mode 100644 index 0000000000..fc6545ee66 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_sum.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 10000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_sum(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_var.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_var.py new file mode 100644 index 0000000000..bfc58877c1 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.StatsMethods.time_var.py @@ -0,0 +1,86 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +DTYPE = 'float64' +SIZE = 10_000 + +LOOP_COUNT = 1000 +_statsmethods = None + + +def setup(): + from bench_core import StatsMethods + global _statsmethods + _statsmethods = StatsMethods() + _statsmethods.setup(DTYPE, SIZE) + + +def __benchmark__(): + # Original workload + _statsmethods.time_var(DTYPE, SIZE) + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large.py new file mode 100644 index 0000000000..c2e3d74a52 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_temporaries = None + + +def setup(): + from bench_core import Temporaries + global _temporaries + _temporaries = Temporaries() + _temporaries.setup() + + +def __benchmark__(): + # Original workload + _temporaries.time_large() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large2.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large2.py new file mode 100644 index 0000000000..9d99e33dd2 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_large2.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_temporaries = None + + +def setup(): + from bench_core import Temporaries + global _temporaries + _temporaries = Temporaries() + _temporaries.setup() + + +def __benchmark__(): + # Original workload + _temporaries.time_large2() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid.py new file mode 100644 index 0000000000..85db0ac146 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_temporaries = None + + +def setup(): + from bench_core import Temporaries + global _temporaries + _temporaries = Temporaries() + _temporaries.setup() + + +def __benchmark__(): + # Original workload + _temporaries.time_mid() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid2.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid2.py new file mode 100644 index 0000000000..856841e42b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.Temporaries.time_mid2.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_temporaries = None + + +def setup(): + from bench_core import Temporaries + global _temporaries + _temporaries = Temporaries() + _temporaries.setup() + + +def __benchmark__(): + # Original workload + _temporaries.time_mid2() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits.py new file mode 100644 index 0000000000..e11c15e7fe --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_unpackbits = None + + +def setup(): + from bench_core import UnpackBits + global _unpackbits + _unpackbits = UnpackBits() + _unpackbits.setup() + + +def __benchmark__(): + # Original workload + _unpackbits.time_unpackbits() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis0.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis0.py new file mode 100644 index 0000000000..0c21e6356b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis0.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 100 +_unpackbits = None + + +def setup(): + from bench_core import UnpackBits + global _unpackbits + _unpackbits = UnpackBits() + _unpackbits.setup() + + +def __benchmark__(): + # Original workload + _unpackbits.time_unpackbits_axis0() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1.py new file mode 100644 index 0000000000..a244c4738e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_unpackbits = None + + +def setup(): + from bench_core import UnpackBits + global _unpackbits + _unpackbits = UnpackBits() + _unpackbits.setup() + + +def __benchmark__(): + # Original workload + _unpackbits.time_unpackbits_axis1() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1_little.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1_little.py new file mode 100644 index 0000000000..953a8c1862 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_axis1_little.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 1000 +_unpackbits = None + + +def setup(): + from bench_core import UnpackBits + global _unpackbits + _unpackbits = UnpackBits() + _unpackbits.setup() + + +def __benchmark__(): + # Original workload + _unpackbits.time_unpackbits_axis1_little() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_little.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_little.py new file mode 100644 index 0000000000..022ff52aa0 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.UnpackBits.time_unpackbits_little.py @@ -0,0 +1,83 @@ +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +LOOP_COUNT = 10000 +_unpackbits = None + + +def setup(): + from bench_core import UnpackBits + global _unpackbits + _unpackbits = UnpackBits() + _unpackbits.setup() + + +def __benchmark__(): + # Original workload + _unpackbits.time_unpackbits_little() + + +def run(): + for _ in range(LOOP_COUNT): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + # Required alongside this file if copied elsewhere + return ["bench_core.py", "common.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.py new file mode 100644 index 0000000000..326f1e3ce9 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/bench_core.py @@ -0,0 +1,259 @@ +import sys +import os +import numpy as np +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +from common import Benchmark + +# Ensure we have numpy version info in the logs +print(f"Using numpy version '{np.__version__}'") + +class Core(Benchmark): + def setup(self): + self.l100 = range(100) + self.l50 = range(50) + self.float_l1000 = [float(i) for i in range(1000)] + self.float64_l1000 = [np.float64(i) for i in range(1000)] + self.int_l1000 = list(range(1000)) + self.l = [np.arange(1000), np.arange(1000)] + self.l_view = [memoryview(a) for a in self.l] + self.l10x10 = np.ones((10, 10)) + self.float64_dtype = np.dtype(np.float64) + + def time_array_1(self): + np.array(1) + + def time_array_empty(self): + np.array([]) + + def time_array_l1(self): + np.array([1]) + + def time_array_l100(self): + np.array(self.l100) + + def time_array_float_l1000(self): + np.array(self.float_l1000) + + def time_array_float_l1000_dtype(self): + np.array(self.float_l1000, dtype=self.float64_dtype) + + def time_array_float64_l1000(self): + np.array(self.float64_l1000) + + def time_array_int_l1000(self): + np.array(self.int_l1000) + + def time_array_l(self): + np.array(self.l) + + def time_array_l_view(self): + np.array(self.l_view) + + def time_can_cast(self): + np.can_cast(self.l10x10, self.float64_dtype) + + def time_can_cast_same_kind(self): + np.can_cast(self.l10x10, self.float64_dtype, casting="same_kind") + + def time_vstack_l(self): + np.vstack(self.l) + + def time_hstack_l(self): + np.hstack(self.l) + + def time_dstack_l(self): + np.dstack(self.l) + + def time_arange_100(self): + np.arange(100) + + def time_zeros_100(self): + np.zeros(100) + + def time_ones_100(self): + np.ones(100) + + def time_empty_100(self): + np.empty(100) + + def time_empty_like(self): + np.empty_like(self.l10x10) + + def time_eye_100(self): + np.eye(100) + + def time_identity_100(self): + np.identity(100) + + def time_eye_3000(self): + np.eye(3000) + + def time_identity_3000(self): + np.identity(3000) + + def time_diag_l100(self): + np.diag(self.l100) + + def time_diagflat_l100(self): + np.diagflat(self.l100) + + def time_diagflat_l50_l50(self): + np.diagflat([self.l50, self.l50]) + + def time_triu_l10x10(self): + np.triu(self.l10x10) + + def time_tril_l10x10(self): + np.tril(self.l10x10) + + def time_triu_indices_500(self): + np.triu_indices(500) + + def time_tril_indices_500(self): + np.tril_indices(500) + + +class Temporaries(Benchmark): + def setup(self): + self.amid = np.ones(50000) + self.bmid = np.ones(50000) + self.alarge = np.ones(1000000) + self.blarge = np.ones(1000000) + + def time_mid(self): + (self.amid * 2) + self.bmid + + def time_mid2(self): + (self.amid + self.bmid) - 2 + + def time_large(self): + (self.alarge * 2) + self.blarge + + def time_large2(self): + (self.alarge + self.blarge) - 2 + + +class CorrConv(Benchmark): + params = [[50, 1000, int(1e5)], + [10, 100, 1000, int(1e4)], + ['valid', 'same', 'full']] + param_names = ['size1', 'size2', 'mode'] + + def setup(self, size1, size2, mode): + self.x1 = np.linspace(0, 1, num=size1) + self.x2 = np.cos(np.linspace(0, 2*np.pi, num=size2)) + + def time_correlate(self, size1, size2, mode): + np.correlate(self.x1, self.x2, mode=mode) + + def time_convolve(self, size1, size2, mode): + np.convolve(self.x1, self.x2, mode=mode) + + +class CountNonzero(Benchmark): + param_names = ['numaxes', 'size', 'dtype'] + params = [ + [1, 2, 3], + [100, 10000, 1000000], + [bool, np.int8, np.int16, np.int32, np.int64, str, object] + ] + + def setup(self, numaxes, size, dtype): + self.x = np.arange(numaxes * size).reshape(numaxes, size) + self.x = (self.x % 3).astype(dtype) + + def time_count_nonzero(self, numaxes, size, dtype): + np.count_nonzero(self.x) + + def time_count_nonzero_axis(self, numaxes, size, dtype): + np.count_nonzero(self.x, axis=self.x.ndim - 1) + + def time_count_nonzero_multi_axis(self, numaxes, size, dtype): + if self.x.ndim >= 2: + np.count_nonzero(self.x, axis=( + self.x.ndim - 1, self.x.ndim - 2)) + + +class PackBits(Benchmark): + param_names = ['dtype'] + params = [[bool, np.uintp]] + def setup(self, dtype): + self.d = np.ones(10000, dtype=dtype) + self.d2 = np.ones((200, 1000), dtype=dtype) + + def time_packbits(self, dtype): + np.packbits(self.d) + + def time_packbits_little(self, dtype): + np.packbits(self.d, bitorder="little") + + def time_packbits_axis0(self, dtype): + np.packbits(self.d2, axis=0) + + def time_packbits_axis1(self, dtype): + np.packbits(self.d2, axis=1) + + +class UnpackBits(Benchmark): + def setup(self): + self.d = np.ones(10000, dtype=np.uint8) + self.d2 = np.ones((200, 1000), dtype=np.uint8) + + def time_unpackbits(self): + np.unpackbits(self.d) + + def time_unpackbits_little(self): + np.unpackbits(self.d, bitorder="little") + + def time_unpackbits_axis0(self): + np.unpackbits(self.d2, axis=0) + + def time_unpackbits_axis1(self): + np.unpackbits(self.d2, axis=1) + + def time_unpackbits_axis1_little(self): + np.unpackbits(self.d2, bitorder="little", axis=1) + + +class Indices(Benchmark): + def time_indices(self): + np.indices((1000, 500)) + + +class StatsMethods(Benchmark): + # Not testing, but in array_api (redundant) + # 8, 16, 32 bit variants, and 128 complexes + params = [['int64', 'uint64', 'float64', 'intp', + 'complex64', 'bool', 'float', 'int', + 'complex', 'complex256'], + [100**n for n in range(0, 2)]] + param_names = ['dtype', 'size'] + + def setup(self, dtype, size): + try: + self.data = np.ones(size, dtype=getattr(np, dtype)) + except AttributeError: # builtins throw AttributeError after 1.20 + self.data = np.ones(size, dtype=dtype) + if dtype.startswith('complex'): + self.data = np.random.randn(size) + 1j * np.random.randn(size) + + def time_min(self, dtype, size): + self.data.min() + + def time_max(self, dtype, size): + self.data.max() + + def time_mean(self, dtype, size): + self.data.mean() + + def time_std(self, dtype, size): + self.data.std() + + def time_prod(self, dtype, size): + self.data.prod() + + def time_var(self, dtype, size): + self.data.var() + + def time_sum(self, dtype, size): + self.data.sum() diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/common.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/common.py new file mode 100644 index 0000000000..4f291dad11 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/numpy/common.py @@ -0,0 +1,224 @@ +import numpy as np +import random +import os +from functools import lru_cache +from pathlib import Path + +# Various pre-crafted datasets/variables for testing +# !!! Must not be changed -- only appended !!! +# while testing numpy we better not rely on numpy to produce random +# sequences +random.seed(1) +# but will seed it nevertheless +np.random.seed(1) + +nx, ny = 1000, 1000 +# reduced squares based on indexes_rand, primarily for testing more +# time-consuming functions (ufunc, linalg, etc) +nxs, nys = 100, 100 + +# a list of interesting types to test +TYPES1 = [ + 'int16', 'float16', + 'int32', 'float32', + 'int64', 'float64', 'complex64', + 'longdouble', 'complex128', +] +if 'complex256' in np.sctypeDict: + TYPES1.append('clongdouble') + +DLPACK_TYPES = [ + 'int16', 'float16', + 'int32', 'float32', + 'int64', 'float64', 'complex64', + 'complex128', 'bool', +] + +# Path for caching +CACHE_ROOT = Path(__file__).resolve().parent.parent / 'env' / 'numpy_benchdata' + +# values which will be used to construct our sample data matrices +# replicate 10 times to speed up initial imports of this helper +# and generate some redundancy + +@lru_cache(typed=True) +def get_values(): + rnd = np.random.RandomState(1) + values = np.tile(rnd.uniform(0, 100, size=nx*ny//10), 10) + return values + + +@lru_cache(typed=True) +def get_square(dtype): + values = get_values() + arr = values.astype(dtype=dtype).reshape((nx, ny)) + + # adjust complex ones to have non-degenerated imagery part -- use + # original data transposed for that + if arr.dtype.kind == 'c': + arr += arr.T*1j + + return arr + +@lru_cache(typed=True) +def get_squares(): + return {t: get_square(t) for t in TYPES1} + + +@lru_cache(typed=True) +def get_square_(dtype): + arr = get_square(dtype) + return arr[:nxs, :nys] + + +@lru_cache(typed=True) +def get_squares_(): + # smaller squares + return {t: get_square_(t) for t in TYPES1} + + +@lru_cache(typed=True) +def get_vectors(): + # vectors + vectors = {t: s[0] for t, s in get_squares().items()} + return vectors + + +@lru_cache(typed=True) +def get_indexes(): + indexes = list(range(nx)) + # so we do not have all items + indexes.pop(5) + indexes.pop(95) + + indexes = np.array(indexes) + return indexes + + +@lru_cache(typed=True) +def get_indexes_rand(): + rnd = random.Random(1) + + indexes_rand = get_indexes().tolist() # copy + rnd.shuffle(indexes_rand) # in-place shuffle + indexes_rand = np.array(indexes_rand) + return indexes_rand + + +@lru_cache(typed=True) +def get_indexes_(): + # smaller versions + indexes = get_indexes() + indexes_ = indexes[indexes < nxs] + return indexes_ + + +@lru_cache(typed=True) +def get_indexes_rand_(): + indexes_rand = get_indexes_rand() + indexes_rand_ = indexes_rand[indexes_rand < nxs] + return indexes_rand_ + + +@lru_cache(typed=True) +def get_data(size, dtype, ip_num=0, zeros=False, finite=True, denormal=False): + """ + Generates a cached random array that covers several scenarios that + may affect the benchmark for fairness and to stabilize the benchmark. + + Parameters + ---------- + size: int + Array length. + + dtype: dtype or dtype specifier + + ip_num: int + Input number, to avoid memory overload + and to provide unique data for each operand. + + zeros: bool + Spreading zeros along with generated data. + + finite: bool + Avoid spreading fp special cases nan/inf. + + denormal: + Spreading subnormal numbers along with generated data. + """ + dtype = np.dtype(dtype) + dname = dtype.name + cache_name = f'{dname}_{size}_{ip_num}_{int(zeros)}' + if dtype.kind in 'fc': + cache_name += f'{int(finite)}{int(denormal)}' + cache_name += '.bin' + cache_path = CACHE_ROOT / cache_name + if cache_path.exists(): + return np.fromfile(cache_path, dtype) + + array = np.ones(size, dtype) + rands = [] + if dtype.kind == 'i': + dinfo = np.iinfo(dtype) + scale = 8 + if zeros: + scale += 1 + lsize = size // scale + for low, high in ( + (-0x80, -1), + (1, 0x7f), + (-0x8000, -1), + (1, 0x7fff), + (-0x80000000, -1), + (1, 0x7fffffff), + (-0x8000000000000000, -1), + (1, 0x7fffffffffffffff), + ): + rands += [np.random.randint( + max(low, dinfo.min), + min(high, dinfo.max), + lsize, dtype + )] + elif dtype.kind == 'u': + dinfo = np.iinfo(dtype) + scale = 4 + if zeros: + scale += 1 + lsize = size // scale + for high in (0xff, 0xffff, 0xffffffff, 0xffffffffffffffff): + rands += [np.random.randint(1, min(high, dinfo.max), lsize, dtype)] + elif dtype.kind in 'fc': + scale = 1 + if zeros: + scale += 1 + if not finite: + scale += 2 + if denormal: + scale += 1 + dinfo = np.finfo(dtype) + lsize = size // scale + rands = [np.random.rand(lsize).astype(dtype)] + if not finite: + rands += [ + np.empty(lsize, dtype=dtype), np.empty(lsize, dtype=dtype) + ] + rands[1].fill(float('nan')) + rands[2].fill(float('inf')) + if denormal: + rands += [np.empty(lsize, dtype=dtype)] + rands[-1].fill(dinfo.smallest_subnormal) + + if rands: + if zeros: + rands += [np.zeros(lsize, dtype)] + stride = len(rands) + for start, r in enumerate(rands): + array[start:len(r)*stride:stride] = r + + if not CACHE_ROOT.exists(): + CACHE_ROOT.mkdir(parents=True) + array.tofile(cache_path) + return array + +class Benchmark: + pass diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script.py new file mode 100644 index 0000000000..f64400e4a4 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script.py @@ -0,0 +1,60406 @@ +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from datetime import datetime, timezone +import sys + +def f1n1(a=1, b=2, c=3.0, s="s1", t="t1", u="u1", p0=2, p1=1.5, p2="p1"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n2(a=2, b=3, c=4.0, s="s2", t="t2"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(34): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(88): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n3(a=3, b=4, c=5.0, s="s3", t="t3"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(39): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n4(a=4, b=5, c=6.0, s="s4", t="t4", u="u4", p0=8, p1=3.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(68): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(97): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n5(a=5, b=6): + c = 7.0 + s = "s5" + t = "t5" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(71): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n6(a=6, b=7, c=8.0, s="s6", t="t6", u="u6", p0=12): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n7(): + a = 7 + b = 8 + c = 9.0 + s = "s7" + t = "t7" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(90): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n8(a=8, b=9, c=10.0, s="s8", t="t8", u="u8", p0=16, p1=5.0, p2="p8"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + return res + +def f1n9(a=9, b=10, c=11.0, s="s9", t="t9"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(33): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n10(): + a = 10 + b = 11 + c = 12.0 + s = "s10" + t = "t10" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(57): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(45): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n11(a=11, b=12, c=13.0): + s = "s11" + t = "t11" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + return res + +def f1n12(a=12, b=13, c=14.0, s="s12", t="t12", u="u12", p0=24): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(25): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n13(a=13, b=14, c=15.0, s="s13", t="t13", u="u13", p0=26, p1=7.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(34): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n14(a=14, b=15, c=16.0, s="s14", t="t14", u="u14", p0=28, p1=8.0, p2="p14", p3=17): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(97): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n15(a=15, b=16, c=17.0, s="s15", t="t15", u="u15", p0=30, p1=8.5, p2="p15"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n16(a=16, b=17, c=18.0, s="s16", t="t16", u="u16"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(41): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n17(a=17, b=18, c=19.0, s="s17", t="t17", u="u17", p0=34, p1=9.5, p2="p17", p3=20): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(24): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n18(a=18, b=19, c=20.0, s="s18", t="t18", u="u18", p0=36, p1=10.0, p2="p18"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + return res + +def f1n19(a=19, b=20, c=21.0, s="s19", t="t19", u="u19", p0=38, p1=10.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(78): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n20(a=20, b=21, c=22.0, s="s20", t="t20", u="u20", p0=40, p1=11.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(9): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n21(a=21, b=22, c=23.0, s="s21"): + t = "t21" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n22(a=22, b=23, c=24.0, s="s22", t="t22", u="u22", p0=44): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n23(): + a = 23 + b = 24 + c = 25.0 + s = "s23" + t = "t23" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(7): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(48): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(57): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n24(a=24, b=25, c=26.0, s="s24"): + t = "t24" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n25(a=25, b=26, c=27.0): + s = "s25" + t = "t25" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(57): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(54): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(96): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n26(a=26, b=27, c=28.0, s="s26"): + t = "t26" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(94): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n27(a=27, b=28, c=29.0, s="s27", t="t27", u="u27", p0=54, p1=14.5, p2="p27", p3=30): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(77): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n28(a=28, b=29, c=30.0, s="s28", t="t28", u="u28", p0=56, p1=15.0, p2="p28"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n29(a=29, b=30, c=31.0): + s = "s29" + t = "t29" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + return res + +def f1n30(a=30, b=31, c=32.0, s="s30", t="t30", u="u30", p0=60, p1=16.0, p2="p30", p3=33): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(26): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(83): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n31(a=31, b=32): + c = 33.0 + s = "s31" + t = "t31" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n32(a=32, b=33, c=34.0, s="s32", t="t32"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n33(a=33, b=34, c=35.0, s="s33", t="t33", u="u33"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(6): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + return res + +def f1n34(a=34, b=35, c=36.0, s="s34", t="t34", u="u34"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n35(a=35, b=36, c=37.0, s="s35", t="t35", u="u35", p0=70, p1=18.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(94): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(96): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n36(a=36, b=37, c=38.0, s="s36", t="t36", u="u36"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(7): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n37(a=37, b=38, c=39.0, s="s37", t="t37", u="u37"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(30): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(37): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n38(a=38, b=39, c=40.0, s="s38", t="t38"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(100): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n39(a=39, b=40, c=41.0, s="s39", t="t39", u="u39"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(9): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + return res + +def f1n40(a=40, b=41, c=42.0, s="s40", t="t40", u="u40", p0=80, p1=21.0, p2="p40", p3=43): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n41(a=41, b=42, c=43.0, s="s41", t="t41", u="u41", p0=82, p1=21.5, p2="p41", p3=44): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(97): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(79): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n42(a=42): + b = 43 + c = 44.0 + s = "s42" + t = "t42" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(94): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n43(a=43, b=44, c=45.0): + s = "s43" + t = "t43" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(26): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n44(a=44, b=45): + c = 46.0 + s = "s44" + t = "t44" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(33): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(49): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n45(a=45): + b = 46 + c = 47.0 + s = "s45" + t = "t45" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n46(a=46, b=47, c=48.0, s="s46"): + t = "t46" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n47(a=47, b=48, c=49.0, s="s47", t="t47", u="u47", p0=94, p1=24.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(2): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n48(a=48, b=49, c=50.0, s="s48", t="t48", u="u48", p0=96, p1=25.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(89): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(12): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n49(a=49, b=50, c=51.0, s="s49", t="t49", u="u49", p0=98, p1=25.5, p2="p49", p3=52): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n50(): + a = 50 + b = 51 + c = 52.0 + s = "s50" + t = "t50" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(88): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + return res + +def f1n51(a=51, b=52, c=53.0, s="s51", t="t51", u="u51", p0=102): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(24): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n52(a=52, b=53, c=54.0, s="s52", t="t52", u="u52", p0=104, p1=27.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(48): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n53(a=53, b=54, c=55.0, s="s53", t="t53"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n54(a=54, b=55, c=56.0): + s = "s54" + t = "t54" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(15): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n55(a=55): + b = 56 + c = 57.0 + s = "s55" + t = "t55" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(2): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n56(): + a = 56 + b = 57 + c = 58.0 + s = "s56" + t = "t56" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n57(a=57, b=58, c=59.0, s="s57", t="t57", u="u57", p0=114, p1=29.5, p2="p57", p3=60): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(8): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n58(a=58, b=59, c=60.0, s="s58", t="t58"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(4): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(5): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n59(a=59, b=60, c=61.0, s="s59"): + t = "t59" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n60(a=60, b=61, c=62.0, s="s60"): + t = "t60" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(5): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(86): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n61(a=61, b=62, c=63.0, s="s61", t="t61", u="u61", p0=122, p1=31.5, p2="p61", p3=64): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(17): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n62(a=62, b=63, c=64.0): + s = "s62" + t = "t62" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n63(a=63, b=64, c=65.0, s="s63", t="t63", u="u63", p0=126): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n64(a=64, b=65, c=66.0): + s = "s64" + t = "t64" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n65(a=65, b=66, c=67.0, s="s65"): + t = "t65" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(15): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n66(a=66, b=67, c=68.0, s="s66"): + t = "t66" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(35): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + return res + +def f1n67(a=67, b=68, c=69.0, s="s67", t="t67", u="u67", p0=134, p1=34.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(26): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n68(a=68, b=69, c=70.0, s="s68", t="t68", u="u68"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n69(a=69, b=70, c=71.0, s="s69", t="t69", u="u69"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(53): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(12): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n70(a=70, b=71, c=72.0, s="s70", t="t70", u="u70"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(95): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n71(a=71, b=72, c=73.0, s="s71", t="t71", u="u71", p0=142, p1=36.5, p2="p71", p3=74): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n72(a=72, b=73, c=74.0, s="s72", t="t72", u="u72", p0=144, p1=37.0, p2="p72", p3=75): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(32): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n73(a=73, b=74, c=75.0, s="s73", t="t73", u="u73"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n74(a=74, b=75, c=76.0, s="s74", t="t74"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(90): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n75(a=75, b=76, c=77.0, s="s75", t="t75", u="u75", p0=150): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n76(a=76, b=77, c=78.0, s="s76", t="t76", u="u76"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n77(a=77, b=78, c=79.0, s="s77"): + t = "t77" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(88): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(26): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + return res + +def f1n78(a=78, b=79, c=80.0, s="s78"): + t = "t78" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(19): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n79(a=79, b=80, c=81.0, s="s79"): + t = "t79" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(82): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(76): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n80(a=80, b=81, c=82.0, s="s80", t="t80", u="u80", p0=160, p1=41.0, p2="p80", p3=83): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(11): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n81(a=81, b=82, c=83.0, s="s81", t="t81", u="u81", p0=162, p1=41.5, p2="p81", p3=84): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(39): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n82(a=82, b=83, c=84.0, s="s82"): + t = "t82" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(100): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(51): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n83(a=83, b=84, c=85.0, s="s83", t="t83", u="u83"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n84(a=84, b=85, c=86.0, s="s84", t="t84", u="u84", p0=168, p1=43.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(32): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n85(a=85, b=86, c=87.0, s="s85", t="t85", u="u85", p0=170, p1=43.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n86(a=86): + b = 87 + c = 88.0 + s = "s86" + t = "t86" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(14): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(26): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n87(a=87, b=88, c=89.0, s="s87", t="t87", u="u87", p0=174, p1=44.5, p2="p87", p3=90): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(51): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(53): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(79): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n88(a=88, b=89, c=90.0, s="s88"): + t = "t88" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(11): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n89(a=89): + b = 90 + c = 91.0 + s = "s89" + t = "t89" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n90(a=90, b=91, c=92.0, s="s90", t="t90", u="u90", p0=180, p1=46.0, p2="p90"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n91(a=91, b=92): + c = 93.0 + s = "s91" + t = "t91" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(72): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n92(a=92, b=93, c=94.0, s="s92", t="t92"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n93(a=93, b=94, c=95.0): + s = "s93" + t = "t93" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(52): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n94(a=94, b=95, c=96.0, s="s94"): + t = "t94" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(53): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n95(a=95, b=96): + c = 97.0 + s = "s95" + t = "t95" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n96(a=96, b=97, c=98.0, s="s96", t="t96", u="u96", p0=192, p1=49.0, p2="p96"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(87): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n97(): + a = 97 + b = 98 + c = 99.0 + s = "s97" + t = "t97" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(16): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(92): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n98(a=98): + b = 99 + c = 100.0 + s = "s98" + t = "t98" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + return res + +def f1n99(a=99, b=100, c=101.0, s="s99", t="t99", u="u99", p0=198): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n100(a=100, b=101, c=102.0, s="s100", t="t100"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(76): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + return res + +def f1n101(a=101, b=102, c=103.0, s="s101", t="t101", u="u101"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(3): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(10): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + return res + +def f1n102(a=102, b=103, c=104.0, s="s102", t="t102", u="u102", p0=204, p1=52.0, p2="p102"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n103(a=103): + b = 104 + c = 105.0 + s = "s103" + t = "t103" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(27): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + return res + +def f1n104(a=104, b=105, c=106.0, s="s104"): + t = "t104" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(8): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(87): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n105(a=105, b=106, c=107.0): + s = "s105" + t = "t105" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(11): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n106(a=106, b=107, c=108.0, s="s106"): + t = "t106" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(99): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n107(a=107, b=108, c=109.0, s="s107", t="t107", u="u107", p0=214, p1=54.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(39): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + return res + +def f1n108(a=108, b=109, c=110.0, s="s108"): + t = "t108" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(66): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n109(a=109, b=110, c=111.0): + s = "s109" + t = "t109" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(56): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(95): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n110(a=110, b=111, c=112.0, s="s110", t="t110"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(24): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + return res + +def f1n111(): + a = 111 + b = 112 + c = 113.0 + s = "s111" + t = "t111" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n112(a=112, b=113, c=114.0, s="s112", t="t112"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(39): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(34): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n113(a=113, b=114, c=115.0, s="s113", t="t113", u="u113", p0=226, p1=57.5, p2="p113", p3=116): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(51): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n114(): + a = 114 + b = 115 + c = 116.0 + s = "s114" + t = "t114" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(74): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(31): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n115(a=115, b=116, c=117.0, s="s115", t="t115", u="u115"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(41): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n116(a=116, b=117, c=118.0, s="s116", t="t116", u="u116", p0=232, p1=59.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(92): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n117(a=117, b=118, c=119.0, s="s117", t="t117", u="u117"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n118(a=118, b=119, c=120.0): + s = "s118" + t = "t118" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n119(a=119, b=120): + c = 121.0 + s = "s119" + t = "t119" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(22): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n120(a=120, b=121, c=122.0, s="s120"): + t = "t120" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(99): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(3): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + return res + +def f1n121(a=121, b=122, c=123.0, s="s121"): + t = "t121" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n122(): + a = 122 + b = 123 + c = 124.0 + s = "s122" + t = "t122" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(57): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(19): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n123(a=123): + b = 124 + c = 125.0 + s = "s123" + t = "t123" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n124(a=124, b=125, c=126.0, s="s124", t="t124"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(30): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(33): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(61): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n125(a=125, b=126, c=127.0, s="s125", t="t125"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n126(a=126, b=127, c=128.0, s="s126", t="t126", u="u126", p0=252, p1=64.0, p2="p126", p3=129): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(29): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n127(a=127, b=128, c=129.0, s="s127", t="t127", u="u127"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(5): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(82): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(81): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + return res + +def f1n128(a=128, b=129, c=130.0, s="s128", t="t128", u="u128", p0=256, p1=65.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(9): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(78): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n129(a=129, b=130, c=131.0, s="s129", t="t129", u="u129", p0=258, p1=65.5, p2="p129", p3=132): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + return res + +def f1n130(a=130, b=131, c=132.0, s="s130", t="t130", u="u130", p0=260): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n131(): + a = 131 + b = 132 + c = 133.0 + s = "s131" + t = "t131" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(78): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n132(a=132, b=133, c=134.0, s="s132", t="t132", u="u132", p0=264): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(59): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n133(a=133): + b = 134 + c = 135.0 + s = "s133" + t = "t133" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(93): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n134(a=134, b=135, c=136.0, s="s134", t="t134", u="u134", p0=268, p1=68.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(99): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(56): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n135(a=135): + b = 136 + c = 137.0 + s = "s135" + t = "t135" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n110() + f1n6() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(15): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + return res + +def f1n136(a=136, b=137, c=138.0, s="s136", t="t136"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n49() + f1n37() + f1n85() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(26): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n137(a=137, b=138, c=139.0, s="s137"): + t = "t137" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n25() + f1n130() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(44): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(42): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n138(): + a = 138 + b = 139 + c = 140.0 + s = "s138" + t = "t138" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n28() + f1n68() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(2): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(17): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n139(a=139, b=140, c=141.0, s="s139", t="t139", u="u139", p0=278, p1=70.5, p2="p139", p3=142): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n3() + f1n93() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(64): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n140(a=140, b=141, c=142.0, s="s140", t="t140", u="u140", p0=280, p1=71.0, p2="p140"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n65() + f1n43() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n141(): + a = 141 + b = 142 + c = 143.0 + s = "s141" + t = "t141" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n118() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(87): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n142(a=142, b=143, c=144.0, s="s142"): + t = "t142" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n16() + f1n40() + f1n88() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(24): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(94): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(4): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n143(a=143, b=144, c=145.0, s="s143", t="t143", u="u143", p0=286, p1=72.5, p2="p143", p3=146): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n6() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n144(a=144, b=145, c=146.0, s="s144", t="t144"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n24() + f1n76() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n145(a=145, b=146, c=147.0, s="s145", t="t145"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n109() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(32): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n146(a=146, b=147, c=148.0, s="s146", t="t146", u="u146", p0=292, p1=74.0, p2="p146", p3=149): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n106() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(87): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n147(a=147, b=148, c=149.0): + s = "s147" + t = "t147" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n24() + f1n68() + f1n94() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(88): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n148(a=148, b=149, c=150.0, s="s148", t="t148", u="u148", p0=296, p1=75.0, p2="p148"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n80() + f1n38() + f1n11() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(56): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n149(a=149, b=150, c=151.0, s="s149", t="t149", u="u149", p0=298, p1=75.5, p2="p149", p3=152): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n125() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(7): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(34): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n150(a=150, b=151): + c = 152.0 + s = "s150" + t = "t150" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n104() + f1n15() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n151(a=151, b=152, c=153.0): + s = "s151" + t = "t151" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n1() + f1n87() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(56): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + return res + +def f1n152(a=152, b=153, c=154.0): + s = "s152" + t = "t152" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n90() + f1n44() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(32): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n153(a=153, b=154, c=155.0, s="s153", t="t153", u="u153", p0=306): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n56() + f1n65() + f1n41() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(39): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + return res + +def f1n154(a=154, b=155, c=156.0, s="s154"): + t = "t154" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n124() + f1n132() + f1n5() + f1n83() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(41): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(5): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(51): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + return res + +def f1n155(a=155, b=156, c=157.0, s="s155", t="t155", u="u155"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n77() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n156(): + a = 156 + b = 157 + c = 158.0 + s = "s156" + t = "t156" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n72() + f1n90() + f1n51() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + return res + +def f1n157(a=157, b=158, c=159.0, s="s157", t="t157", u="u157", p0=314, p1=79.5, p2="p157"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n35() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(51): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(92): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(20): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n158(a=158, b=159, c=160.0, s="s158", t="t158", u="u158", p0=316, p1=80.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n3() + f1n4() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(7): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(35): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(58): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + return res + +def f1n159(a=159, b=160, c=161.0, s="s159", t="t159", u="u159"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n113() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(47): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(41): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n160(): + a = 160 + b = 161 + c = 162.0 + s = "s160" + t = "t160" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n120() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(88): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(9): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n161(a=161, b=162, c=163.0, s="s161", t="t161", u="u161", p0=322, p1=81.5, p2="p161"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n106() + f1n28() + f1n20() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n162(a=162, b=163, c=164.0, s="s162", t="t162", u="u162", p0=324, p1=82.0, p2="p162", p3=165): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n89() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(98): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + return res + +def f1n163(a=163, b=164, c=165.0, s="s163", t="t163", u="u163", p0=326): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n35() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(78): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n164(): + a = 164 + b = 165 + c = 166.0 + s = "s164" + t = "t164" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n70() + f1n39() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n165(a=165, b=166): + c = 167.0 + s = "s165" + t = "t165" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n1() + f1n50() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(41): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n166(a=166, b=167, c=168.0): + s = "s166" + t = "t166" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n120() + f1n116() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(9): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n167(a=167, b=168, c=169.0): + s = "s167" + t = "t167" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n131() + f1n7() + f1n66() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(70): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(31): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n168(a=168, b=169, c=170.0, s="s168", t="t168", u="u168", p0=336, p1=85.0, p2="p168", p3=171): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n40() + f1n131() + f1n70() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(49): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n169(a=169): + b = 170 + c = 171.0 + s = "s169" + t = "t169" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n123() + f1n112() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(51): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(80): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(23): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n170(a=170, b=171, c=172.0): + s = "s170" + t = "t170" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n80() + f1n17() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(2): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(54): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(87): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n171(a=171, b=172, c=173.0, s="s171", t="t171", u="u171"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n128() + f1n110() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n172(a=172): + b = 173 + c = 174.0 + s = "s172" + t = "t172" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n3() + f1n28() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n173(a=173, b=174, c=175.0, s="s173", t="t173"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n96() + f1n65() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(21): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n174(a=174, b=175, c=176.0, s="s174", t="t174", u="u174", p0=348, p1=88.0, p2="p174", p3=177): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n5() + f1n31() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(58): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n175(a=175): + b = 176 + c = 177.0 + s = "s175" + t = "t175" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n90() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n176(a=176, b=177, c=178.0): + s = "s176" + t = "t176" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n101() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(39): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n177(a=177, b=178, c=179.0, s="s177", t="t177", u="u177", p0=354, p1=89.5, p2="p177"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n17() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(11): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(67): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n178(a=178, b=179, c=180.0, s="s178", t="t178", u="u178", p0=356, p1=90.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n81() + f1n67() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n179(a=179, b=180, c=181.0, s="s179", t="t179"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n134() + f1n55() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(29): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(35): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n180(a=180): + b = 181 + c = 182.0 + s = "s180" + t = "t180" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n89() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(78): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n181(a=181, b=182, c=183.0, s="s181", t="t181", u="u181", p0=362, p1=91.5, p2="p181", p3=184): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n73() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n182(a=182, b=183, c=184.0, s="s182", t="t182", u="u182"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n105() + f1n124() + f1n60() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n183(a=183, b=184, c=185.0, s="s183", t="t183", u="u183"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n50() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(45): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n184(a=184, b=185, c=186.0, s="s184", t="t184", u="u184", p0=368, p1=93.0, p2="p184"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n54() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(21): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n185(a=185, b=186, c=187.0, s="s185", t="t185", u="u185", p0=370, p1=93.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n23() + f1n118() + f1n119() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(98): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n186(a=186, b=187, c=188.0, s="s186", t="t186", u="u186", p0=372, p1=94.0, p2="p186", p3=189): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n95() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(100): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(37): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n187(a=187, b=188, c=189.0, s="s187", t="t187", u="u187", p0=374, p1=94.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n96() + f1n7() + f1n79() + f1n75() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(71): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(54): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n188(a=188, b=189, c=190.0, s="s188"): + t = "t188" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n121() + f1n2() + f1n127() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + return res + +def f1n189(): + a = 189 + b = 190 + c = 191.0 + s = "s189" + t = "t189" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n40() + f1n30() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(2): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(49): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n190(a=190, b=191, c=192.0, s="s190"): + t = "t190" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n44() + f1n53() + f1n103() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n191(a=191): + b = 192 + c = 193.0 + s = "s191" + t = "t191" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n98() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n192(a=192): + b = 193 + c = 194.0 + s = "s192" + t = "t192" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n2() + f1n26() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n193(a=193, b=194, c=195.0, s="s193", t="t193", u="u193", p0=386): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n86() + f1n58() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(95): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n194(): + a = 194 + b = 195 + c = 196.0 + s = "s194" + t = "t194" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n27() + f1n28() + f1n77() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(9): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(57): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n195(a=195, b=196, c=197.0, s="s195", t="t195", u="u195", p0=390): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n72() + f1n100() + f1n13() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(11): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n196(a=196, b=197, c=198.0, s="s196", t="t196", u="u196"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n114() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(18): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n197(a=197, b=198, c=199.0, s="s197", t="t197"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n40() + f1n114() + f1n5() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n198(a=198, b=199, c=200.0, s="s198", t="t198"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n128() + f1n82() + f1n107() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(57): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + return res + +def f1n199(a=199, b=200, c=201.0): + s = "s199" + t = "t199" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n92() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + return res + +def f1n200(a=200, b=201, c=202.0, s="s200", t="t200"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n115() + f1n124() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(80): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(54): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n201(a=201): + b = 202 + c = 203.0 + s = "s201" + t = "t201" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n129() + f1n93() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(51): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(98): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n202(a=202, b=203, c=204.0, s="s202"): + t = "t202" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n97() + f1n98() + f1n19() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(70): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + return res + +def f1n203(a=203): + b = 204 + c = 205.0 + s = "s203" + t = "t203" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n60() + f1n125() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(89): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(15): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + return res + +def f1n204(a=204, b=205, c=206.0, s="s204", t="t204", u="u204"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n72() + f1n96() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(83): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n205(a=205, b=206, c=207.0, s="s205", t="t205", u="u205", p0=410, p1=103.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n81() + f1n14() + f1n1() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n206(a=206, b=207, c=208.0, s="s206", t="t206", u="u206", p0=412, p1=104.0, p2="p206"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n68() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(72): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(49): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n207(a=207, b=208, c=209.0, s="s207", t="t207", u="u207", p0=414, p1=104.5, p2="p207"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n51() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(76): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n208(a=208, b=209): + c = 210.0 + s = "s208" + t = "t208" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n52() + f1n14() + f1n63() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(98): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(91): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(88): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n209(a=209, b=210, c=211.0, s="s209", t="t209", u="u209"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n21() + f1n45() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n210(a=210, b=211, c=212.0, s="s210", t="t210", u="u210", p0=420, p1=106.0, p2="p210", p3=213): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n108() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(19): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n211(a=211): + b = 212 + c = 213.0 + s = "s211" + t = "t211" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n73() + f1n62() + f1n71() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(26): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(58): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n212(): + a = 212 + b = 213 + c = 214.0 + s = "s212" + t = "t212" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n6() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n213(a=213, b=214, c=215.0, s="s213"): + t = "t213" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n92() + f1n118() + f1n119() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + return res + +def f1n214(a=214, b=215, c=216.0, s="s214", t="t214", u="u214", p0=428): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n14() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(56): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(51): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(67): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n215(a=215, b=216, c=217.0, s="s215", t="t215", u="u215", p0=430, p1=108.5, p2="p215", p3=218): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n115() + f1n14() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(71): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(90): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n216(a=216, b=217, c=218.0, s="s216", t="t216"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n76() + f1n47() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n217(a=217, b=218, c=219.0, s="s217", t="t217", u="u217", p0=434): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n1() + f1n69() + f1n70() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(72): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(50): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(75): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + return res + +def f1n218(a=218, b=219, c=220.0, s="s218", t="t218", u="u218"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n128() + f1n15() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(14): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n219(a=219, b=220, c=221.0, s="s219", t="t219"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n108() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n220(a=220, b=221, c=222.0): + s = "s220" + t = "t220" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n130() + f1n68() + f1n91() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(32): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(64): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(98): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n221(a=221, b=222, c=223.0, s="s221", t="t221", u="u221"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n15() + f1n95() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(15): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n222(a=222, b=223, c=224.0, s="s222", t="t222", u="u222", p0=444, p1=112.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n50() + f1n60() + f1n78() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(89): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(73): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(36): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n223(a=223, b=224, c=225.0): + s = "s223" + t = "t223" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n114() + f1n61() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(16): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n224(a=224, b=225, c=226.0, s="s224", t="t224", u="u224", p0=448, p1=113.0, p2="p224", p3=227): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n128() + f1n53() + f1n47() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(74): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n225(a=225): + b = 226 + c = 227.0 + s = "s225" + t = "t225" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n77() + f1n5() + f1n54() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n226(a=226, b=227, c=228.0): + s = "s226" + t = "t226" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n56() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(65): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n227(a=227, b=228, c=229.0): + s = "s227" + t = "t227" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n84() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(68): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + return res + +def f1n228(a=228, b=229, c=230.0, s="s228", t="t228", u="u228", p0=456, p1=115.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n3() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n229(): + a = 229 + b = 230 + c = 231.0 + s = "s229" + t = "t229" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n108() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n230(a=230, b=231, c=232.0, s="s230", t="t230", u="u230", p0=460, p1=116.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n56() + f1n90() + f1n99() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n231(a=231): + b = 232 + c = 233.0 + s = "s231" + t = "t231" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n8() + f1n133() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(89): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(34): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n232(a=232, b=233, c=234.0): + s = "s232" + t = "t232" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n126() + f1n95() + f1n42() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(12): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(55): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n233(): + a = 233 + b = 234 + c = 235.0 + s = "s233" + t = "t233" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n48() + f1n9() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n234(a=234, b=235, c=236.0): + s = "s234" + t = "t234" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n76() + f1n38() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(16): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(93): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(48): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n235(): + a = 235 + b = 236 + c = 237.0 + s = "s235" + t = "t235" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n81() + f1n54() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n236(a=236, b=237, c=238.0, s="s236", t="t236"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n12() + f1n93() + f1n44() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n237(a=237, b=238, c=239.0, s="s237"): + t = "t237" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n10() + f1n98() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(95): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n238(a=238, b=239, c=240.0): + s = "s238" + t = "t238" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n106() + f1n71() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + return res + +def f1n239(a=239, b=240, c=241.0, s="s239", t="t239", u="u239", p0=478, p1=120.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n104() + f1n125() + f1n22() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(90): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n240(a=240, b=241, c=242.0, s="s240"): + t = "t240" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n16() + f1n79() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n241(a=241, b=242, c=243.0, s="s241", t="t241", u="u241"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n19() + f1n53() + f1n29() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(12): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(51): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n242(a=242, b=243, c=244.0, s="s242", t="t242", u="u242", p0=484, p1=122.0, p2="p242", p3=245): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n59() + f1n36() + f1n46() + f1n18() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(74): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n243(a=243, b=244, c=245.0, s="s243", t="t243", u="u243", p0=486, p1=122.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n122() + f1n111() + f1n7() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n244(): + a = 244 + b = 245 + c = 246.0 + s = "s244" + t = "t244" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n97() + f1n130() + f1n114() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(39): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(62): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n245(a=245): + b = 246 + c = 247.0 + s = "s245" + t = "t245" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n49() + f1n9() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n246(a=246, b=247): + c = 248.0 + s = "s246" + t = "t246" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n110() + f1n99() + f1n22() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + return res + +def f1n247(a=247, b=248, c=249.0, s="s247", t="t247", u="u247", p0=494): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n59() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(24): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + return res + +def f1n248(a=248, b=249, c=250.0, s="s248", t="t248", u="u248"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n25() + f1n98() + f1n87() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n249(a=249, b=250): + c = 251.0 + s = "s249" + t = "t249" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n126() + f1n14() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(83): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n250(a=250, b=251, c=252.0, s="s250", t="t250", u="u250", p0=500, p1=126.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n74() + f1n69() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(98): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n251(a=251, b=252, c=253.0, s="s251"): + t = "t251" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n132() + f1n21() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(13): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n252(a=252, b=253, c=254.0, s="s252", t="t252", u="u252", p0=504, p1=127.0, p2="p252", p3=255): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n104() + f1n121() + f1n102() + f1n32() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(19): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n253(a=253, b=254, c=255.0): + s = "s253" + t = "t253" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n130() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n254(a=254, b=255, c=256.0, s="s254", t="t254", u="u254", p0=508, p1=128.0, p2="p254", p3=257): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n48() + f1n128() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(49): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n255(a=255): + b = 256 + c = 257.0 + s = "s255" + t = "t255" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n123() + f1n36() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(74): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(76): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n256(a=256, b=257, c=258.0, s="s256", t="t256", u="u256", p0=512, p1=129.0, p2="p256"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n57() + f1n36() + f1n63() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n257(a=257, b=258, c=259.0, s="s257", t="t257"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n121() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(59): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(38): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n258(a=258, b=259, c=260.0, s="s258"): + t = "t258" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n115() + f1n39() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(40): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n259(a=259, b=260, c=261.0, s="s259", t="t259", u="u259"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n119() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n260(a=260, b=261, c=262.0, s="s260", t="t260", u="u260", p0=520, p1=131.0, p2="p260", p3=263): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n90() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(53): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(69): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n261(a=261, b=262, c=263.0, s="s261", t="t261", u="u261"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n117() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(56): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + return res + +def f1n262(): + a = 262 + b = 263 + c = 264.0 + s = "s262" + t = "t262" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n115() + f1n92() + f1n44() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(52): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n263(a=263, b=264, c=265.0, s="s263", t="t263"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n8() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n264(a=264, b=265, c=266.0): + s = "s264" + t = "t264" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n8() + f1n81() + f1n121() + f1n33() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(10): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n265(a=265, b=266, c=267.0, s="s265", t="t265", u="u265", p0=530, p1=133.5, p2="p265", p3=268): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n16() + f1n57() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(26): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n266(a=266, b=267, c=268.0, s="s266", t="t266", u="u266"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n34() + f1n20() + f1n64() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(88): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n267(a=267, b=268, c=269.0, s="s267", t="t267", u="u267", p0=534, p1=134.5, p2="p267"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n20() + f1n109() + f1n46() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(15): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n268(a=268, b=269, c=270.0, s="s268"): + t = "t268" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n185() + f1n170() + f1n257() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n269(a=269, b=270, c=271.0, s="s269"): + t = "t269" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n197() + f1n253() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n270(): + a = 270 + b = 271 + c = 272.0 + s = "s270" + t = "t270" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n208() + f1n266() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(87): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n271(a=271, b=272, c=273.0, s="s271", t="t271", u="u271", p0=542): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n135() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n272(a=272, b=273, c=274.0, s="s272"): + t = "t272" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n236() + f1n246() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(80): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n273(a=273, b=274, c=275.0, s="s273", t="t273"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n146() + f1n259() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(73): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n274(a=274, b=275, c=276.0): + s = "s274" + t = "t274" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n240() + f1n204() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(82): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n275(a=275, b=276, c=277.0): + s = "s275" + t = "t275" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n267() + f1n188() + f1n237() + f1n216() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(59): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(100): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n276(a=276, b=277, c=278.0): + s = "s276" + t = "t276" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n169() + f1n204() + f1n263() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n277(): + a = 277 + b = 278 + c = 279.0 + s = "s277" + t = "t277" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n187() + f1n181() + f1n239() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(17): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n278(): + a = 278 + b = 279 + c = 280.0 + s = "s278" + t = "t278" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n242() + f1n226() + f1n187() + f1n249() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(51): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(77): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n279(a=279, b=280, c=281.0, s="s279", t="t279"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n203() + f1n156() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n280(a=280, b=281, c=282.0, s="s280", t="t280", u="u280", p0=560, p1=141.0, p2="p280"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n165() + f1n262() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n281(a=281, b=282, c=283.0, s="s281", t="t281", u="u281", p0=562, p1=141.5, p2="p281"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n239() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(87): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n282(a=282): + b = 283 + c = 284.0 + s = "s282" + t = "t282" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n177() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + return res + +def f1n283(): + a = 283 + b = 284 + c = 285.0 + s = "s283" + t = "t283" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n248() + f1n218() + f1n167() + f1n231() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n284(a=284, b=285, c=286.0, s="s284", t="t284", u="u284"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n171() + f1n182() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(31): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + return res + +def f1n285(a=285, b=286, c=287.0): + s = "s285" + t = "t285" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n241() + f1n228() + f1n141() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(88): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(60): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n286(a=286, b=287, c=288.0, s="s286", t="t286", u="u286", p0=572, p1=144.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n254() + f1n189() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n287(a=287, b=288, c=289.0, s="s287", t="t287", u="u287", p0=574, p1=144.5, p2="p287", p3=290): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n161() + f1n147() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n288(a=288, b=289, c=290.0, s="s288", t="t288", u="u288", p0=576, p1=145.0, p2="p288", p3=291): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n220() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(45): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(7): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n289(): + a = 289 + b = 290 + c = 291.0 + s = "s289" + t = "t289" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n145() + f1n196() + f1n201() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(77): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n290(a=290, b=291, c=292.0, s="s290", t="t290", u="u290", p0=580): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n200() + f1n173() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(48): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n291(): + a = 291 + b = 292 + c = 293.0 + s = "s291" + t = "t291" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n164() + f1n247() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(65): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n292(a=292, b=293, c=294.0, s="s292", t="t292", u="u292", p0=584, p1=147.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n148() + f1n167() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n293(a=293, b=294, c=295.0, s="s293", t="t293", u="u293", p0=586, p1=147.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n159() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(58): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(37): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(99): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n294(a=294, b=295, c=296.0, s="s294", t="t294", u="u294", p0=588, p1=148.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n138() + f1n267() + f1n182() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(50): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n295(a=295, b=296, c=297.0, s="s295", t="t295", u="u295", p0=590): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n257() + f1n141() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(23): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n296(a=296, b=297): + c = 298.0 + s = "s296" + t = "t296" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n257() + f1n245() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(24): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + return res + +def f1n297(): + a = 297 + b = 298 + c = 299.0 + s = "s297" + t = "t297" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n241() + f1n180() + f1n165() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(87): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n298(a=298, b=299, c=300.0, s="s298", t="t298", u="u298", p0=596): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n225() + f1n266() + f1n146() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n299(a=299, b=300, c=301.0): + s = "s299" + t = "t299" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n264() + f1n174() + f1n154() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n300(): + a = 300 + b = 301 + c = 302.0 + s = "s300" + t = "t300" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n253() + f1n238() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(1): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(83): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n301(a=301, b=302): + c = 303.0 + s = "s301" + t = "t301" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n267() + f1n213() + f1n135() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(32): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n302(a=302, b=303): + c = 304.0 + s = "s302" + t = "t302" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n234() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n303(): + a = 303 + b = 304 + c = 305.0 + s = "s303" + t = "t303" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n145() + f1n171() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(89): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(13): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(15): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n304(a=304): + b = 305 + c = 306.0 + s = "s304" + t = "t304" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n185() + f1n180() + f1n166() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n305(a=305, b=306, c=307.0, s="s305"): + t = "t305" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n209() + f1n195() + f1n260() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(5): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n306(a=306): + b = 307 + c = 308.0 + s = "s306" + t = "t306" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n193() + f1n267() + f1n238() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(29): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(15): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n307(a=307, b=308, c=309.0, s="s307", t="t307", u="u307", p0=614, p1=154.5, p2="p307"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n236() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(82): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(95): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + return res + +def f1n308(a=308, b=309, c=310.0): + s = "s308" + t = "t308" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n239() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(89): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n309(a=309, b=310, c=311.0, s="s309"): + t = "t309" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n147() + f1n182() + f1n247() + f1n229() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n310(a=310, b=311, c=312.0, s="s310"): + t = "t310" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n146() + f1n164() + f1n191() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(95): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(8): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(56): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + return res + +def f1n311(a=311, b=312, c=313.0, s="s311"): + t = "t311" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n250() + f1n174() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n312(a=312, b=313, c=314.0, s="s312", t="t312", u="u312", p0=624, p1=157.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n136() + f1n164() + f1n208() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(30): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(51): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n313(): + a = 313 + b = 314 + c = 315.0 + s = "s313" + t = "t313" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n265() + f1n181() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(53): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n314(a=314, b=315, c=316.0, s="s314", t="t314", u="u314", p0=628, p1=158.0, p2="p314"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n213() + f1n199() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(71): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n315(a=315, b=316, c=317.0, s="s315", t="t315", u="u315"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n178() + f1n179() + f1n244() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(49): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + return res + +def f1n316(a=316, b=317, c=318.0, s="s316", t="t316", u="u316", p0=632, p1=159.0, p2="p316", p3=319): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n139() + f1n206() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + return res + +def f1n317(a=317): + b = 318 + c = 319.0 + s = "s317" + t = "t317" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n238() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(59): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n318(a=318): + b = 319 + c = 320.0 + s = "s318" + t = "t318" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n188() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(65): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(54): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n319(a=319, b=320, c=321.0, s="s319", t="t319", u="u319"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n208() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(21): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n320(): + a = 320 + b = 321 + c = 322.0 + s = "s320" + t = "t320" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n219() + f1n188() + f1n223() + f1n230() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(19): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(36): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n321(a=321, b=322, c=323.0, s="s321", t="t321", u="u321", p0=642, p1=161.5, p2="p321", p3=324): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n135() + f1n261() + f1n191() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n322(a=322, b=323): + c = 324.0 + s = "s322" + t = "t322" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n236() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n323(a=323): + b = 324 + c = 325.0 + s = "s323" + t = "t323" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n257() + f1n251() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(92): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n324(a=324): + b = 325 + c = 326.0 + s = "s324" + t = "t324" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n260() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(76): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n325(a=325, b=326): + c = 327.0 + s = "s325" + t = "t325" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n174() + f1n159() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n326(a=326, b=327): + c = 328.0 + s = "s326" + t = "t326" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n205() + f1n166() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + return res + +def f1n327(a=327, b=328, c=329.0, s="s327", t="t327", u="u327"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n160() + f1n257() + f1n243() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(99): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(58): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n328(a=328, b=329, c=330.0, s="s328"): + t = "t328" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n163() + f1n228() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(12): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(77): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n329(a=329, b=330, c=331.0, s="s329", t="t329", u="u329", p0=658, p1=165.5, p2="p329"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n244() + f1n263() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(4): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(72): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n330(a=330, b=331, c=332.0, s="s330", t="t330", u="u330", p0=660, p1=166.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n168() + f1n236() + f1n217() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(37): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(27): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(26): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n331(a=331, b=332): + c = 333.0 + s = "s331" + t = "t331" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n179() + f1n166() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n332(a=332, b=333, c=334.0, s="s332", t="t332", u="u332"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n137() + f1n211() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(1): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n333(): + a = 333 + b = 334 + c = 335.0 + s = "s333" + t = "t333" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n252() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + return res + +def f1n334(): + a = 334 + b = 335 + c = 336.0 + s = "s334" + t = "t334" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n195() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n335(a=335, b=336, c=337.0, s="s335", t="t335", u="u335"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n188() + f1n243() + f1n252() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(65): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n336(a=336, b=337, c=338.0, s="s336", t="t336", u="u336", p0=672, p1=169.0, p2="p336", p3=339): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n171() + f1n174() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n337(a=337, b=338, c=339.0, s="s337", t="t337", u="u337", p0=674, p1=169.5, p2="p337"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n174() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n338(a=338, b=339, c=340.0, s="s338", t="t338", u="u338", p0=676, p1=170.0, p2="p338", p3=341): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n196() + f1n244() + f1n150() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(47): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(81): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n339(a=339, b=340, c=341.0, s="s339", t="t339", u="u339", p0=678, p1=170.5, p2="p339"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n179() + f1n140() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(15): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n340(a=340, b=341, c=342.0, s="s340", t="t340", u="u340", p0=680): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n210() + f1n166() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(37): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n341(a=341, b=342, c=343.0, s="s341", t="t341", u="u341", p0=682): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n211() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(89): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n342(a=342, b=343): + c = 344.0 + s = "s342" + t = "t342" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n186() + f1n180() + f1n255() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n343(a=343, b=344): + c = 345.0 + s = "s343" + t = "t343" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n137() + f1n202() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n344(a=344, b=345, c=346.0, s="s344", t="t344", u="u344", p0=688): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n233() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(82): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n345(a=345, b=346, c=347.0, s="s345", t="t345", u="u345", p0=690, p1=173.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n212() + f1n165() + f1n182() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n346(a=346, b=347): + c = 348.0 + s = "s346" + t = "t346" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n177() + f1n191() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(29): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(32): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n347(a=347, b=348, c=349.0, s="s347", t="t347", u="u347", p0=694, p1=174.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n260() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n348(a=348, b=349, c=350.0, s="s348"): + t = "t348" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n136() + f1n137() + f1n151() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(87): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n349(a=349, b=350, c=351.0, s="s349", t="t349", u="u349", p0=698): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n155() + f1n228() + f1n247() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(9): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n350(a=350, b=351): + c = 352.0 + s = "s350" + t = "t350" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n234() + f1n211() + f1n188() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(21): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n351(a=351, b=352): + c = 353.0 + s = "s351" + t = "t351" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n210() + f1n266() + f1n214() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(100): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(33): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n352(): + a = 352 + b = 353 + c = 354.0 + s = "s352" + t = "t352" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n209() + f1n171() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(74): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + return res + +def f1n353(a=353, b=354, c=355.0, s="s353", t="t353", u="u353", p0=706, p1=177.5, p2="p353"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n138() + f1n141() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(85): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + return res + +def f1n354(a=354, b=355, c=356.0, s="s354", t="t354", u="u354"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n188() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(14): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n355(): + a = 355 + b = 356 + c = 357.0 + s = "s355" + t = "t355" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n138() + f1n149() + f1n207() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(3): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(9): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n356(a=356, b=357, c=358.0, s="s356", t="t356", u="u356", p0=712, p1=179.0, p2="p356"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n228() + f1n159() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(98): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(29): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + return res + +def f1n357(a=357, b=358, c=359.0, s="s357", t="t357", u="u357", p0=714): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n265() + f1n252() + f1n199() + f1n142() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(78): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n358(a=358, b=359, c=360.0, s="s358", t="t358", u="u358", p0=716): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n176() + f1n150() + f1n160() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(59): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(11): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n359(a=359, b=360, c=361.0, s="s359", t="t359", u="u359", p0=718, p1=180.5, p2="p359", p3=362): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n160() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(98): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n360(): + a = 360 + b = 361 + c = 362.0 + s = "s360" + t = "t360" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n159() + f1n265() + f1n263() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n361(a=361, b=362, c=363.0, s="s361", t="t361"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n198() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(77): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n362(a=362, b=363, c=364.0, s="s362", t="t362", u="u362"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n251() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(85): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(73): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n363(a=363, b=364, c=365.0, s="s363", t="t363", u="u363", p0=726, p1=182.5, p2="p363"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n194() + f1n214() + f1n215() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(84): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(6): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n364(a=364, b=365, c=366.0, s="s364", t="t364", u="u364", p0=728, p1=183.0, p2="p364", p3=367): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n180() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(98): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + return res + +def f1n365(a=365, b=366, c=367.0, s="s365", t="t365"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n242() + f1n159() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(52): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(96): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(52): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n366(a=366, b=367, c=368.0, s="s366", t="t366", u="u366", p0=732, p1=184.0, p2="p366", p3=369): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n160() + f1n235() + f1n172() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(24): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(84): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n367(a=367, b=368, c=369.0, s="s367", t="t367", u="u367", p0=734, p1=184.5, p2="p367", p3=370): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n200() + f1n224() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(72): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n368(a=368, b=369, c=370.0, s="s368", t="t368", u="u368"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n146() + f1n254() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(85): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(84): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(18): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n369(a=369, b=370, c=371.0, s="s369", t="t369", u="u369", p0=738): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n210() + f1n234() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(52): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(24): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n370(a=370, b=371, c=372.0, s="s370", t="t370", u="u370", p0=740): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n208() + f1n243() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n371(a=371, b=372, c=373.0): + s = "s371" + t = "t371" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n200() + f1n149() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(41): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + return res + +def f1n372(a=372, b=373, c=374.0, s="s372", t="t372", u="u372", p0=744): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n210() + f1n203() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n373(a=373, b=374, c=375.0, s="s373", t="t373", u="u373", p0=746, p1=187.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n263() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(71): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(66): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(48): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n374(a=374, b=375, c=376.0, s="s374"): + t = "t374" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n184() + f1n203() + f1n158() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n375(a=375): + b = 376 + c = 377.0 + s = "s375" + t = "t375" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n243() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(3): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n376(a=376, b=377, c=378.0, s="s376", t="t376", u="u376", p0=752, p1=189.0, p2="p376", p3=379): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n202() + f1n239() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(74): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n377(a=377): + b = 378 + c = 379.0 + s = "s377" + t = "t377" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n156() + f1n157() + f1n143() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n378(): + a = 378 + b = 379 + c = 380.0 + s = "s378" + t = "t378" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n152() + f1n262() + f1n183() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(96): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(83): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + return res + +def f1n379(a=379, b=380, c=381.0, s="s379", t="t379", u="u379", p0=758): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n144() + f1n197() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n380(a=380, b=381, c=382.0, s="s380"): + t = "t380" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n173() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(100): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n381(a=381, b=382, c=383.0): + s = "s381" + t = "t381" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n136() + f1n186() + f1n196() + f1n227() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(98): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n382(a=382, b=383, c=384.0, s="s382", t="t382", u="u382", p0=764, p1=192.0, p2="p382"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n258() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(20): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n383(a=383, b=384, c=385.0, s="s383", t="t383", u="u383", p0=766, p1=192.5, p2="p383", p3=386): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n202() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(19): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n384(a=384, b=385): + c = 386.0 + s = "s384" + t = "t384" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n196() + f1n149() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(30): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(48): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n385(a=385, b=386, c=387.0, s="s385", t="t385", u="u385", p0=770): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n168() + f1n205() + f1n245() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + x = x + 1 - 1 + return res + +def f1n386(a=386, b=387, c=388.0, s="s386", t="t386", u="u386", p0=772, p1=194.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n252() + f1n215() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(22): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(67): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + return res + +def f1n387(a=387, b=388, c=389.0, s="s387", t="t387"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n256() + f1n162() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n388(a=388, b=389, c=390.0, s="s388", t="t388", u="u388"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n232() + f1n175() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(80): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n389(a=389, b=390, c=391.0): + s = "s389" + t = "t389" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n201() + f1n153() + f1n253() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(21): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n390(a=390, b=391): + c = 392.0 + s = "s390" + t = "t390" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n265() + f1n235() + f1n245() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(58): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n391(a=391, b=392, c=393.0, s="s391", t="t391", u="u391", p0=782, p1=196.5, p2="p391", p3=394): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n168() + f1n188() + f1n262() + f1n190() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n392(a=392, b=393, c=394.0): + s = "s392" + t = "t392" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n213() + f1n222() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(83): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(56): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n393(a=393, b=394, c=395.0, s="s393", t="t393", u="u393", p0=786, p1=197.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n186() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(87): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n394(a=394, b=395, c=396.0, s="s394", t="t394", u="u394", p0=788, p1=198.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n258() + f1n236() + f1n221() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(94): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(66): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n395(a=395, b=396, c=397.0, s="s395", t="t395", u="u395", p0=790): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n259() + f1n262() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n396(a=396, b=397, c=398.0, s="s396", t="t396", u="u396", p0=792): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n228() + f1n239() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(89): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(54): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def f1n397(a=397, b=398): + c = 399.0 + s = "s397" + t = "t397" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n201() + f1n210() + f1n163() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n398(a=398, b=399, c=400.0, s="s398", t="t398"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n192() + f1n171() + f1n168() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(53): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + return res + +def f1n399(a=399, b=400, c=401.0, s="s399"): + t = "t399" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n256() + f1n136() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(54): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n400(): + a = 400 + b = 401 + c = 402.0 + s = "s400" + t = "t400" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n208() + f1n186() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + return res + +def f1n401(a=401, b=402, c=403.0, s="s401", t="t401", u="u401", p0=802): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n320() + f1n393() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(25): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(6): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(42): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + return res + +def f1n402(a=402, b=403, c=404.0, s="s402", t="t402", u="u402", p0=804, p1=202.0, p2="p402", p3=405): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n337() + f1n308() + f1n350() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(4): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(13): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n403(a=403, b=404, c=405.0, s="s403", t="t403", u="u403", p0=806): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n302() + f1n326() + f1n390() + f1n287() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(99): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n404(a=404): + b = 405 + c = 406.0 + s = "s404" + t = "t404" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n354() + f1n342() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(9): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(64): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n405(a=405, b=406, c=407.0): + s = "s405" + t = "t405" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n369() + f1n301() + f1n297() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + return res + +def f1n406(a=406, b=407, c=408.0, s="s406", t="t406", u="u406"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n315() + f1n293() + f1n395() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(6): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n407(): + a = 407 + b = 408 + c = 409.0 + s = "s407" + t = "t407" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n358() + f1n360() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(74): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(88): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n408(a=408, b=409, c=410.0, s="s408"): + t = "t408" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n315() + f1n359() + f1n335() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n409(a=409, b=410, c=411.0, s="s409"): + t = "t409" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n352() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n410(a=410, b=411, c=412.0, s="s410", t="t410", u="u410", p0=820, p1=206.0, p2="p410"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n299() + f1n315() + f1n333() + f1n296() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + return res + +def f1n411(a=411): + b = 412 + c = 413.0 + s = "s411" + t = "t411" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n370() + f1n294() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(38): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(51): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n412(a=412, b=413, c=414.0, s="s412", t="t412", u="u412", p0=824, p1=207.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n386() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n413(a=413, b=414, c=415.0, s="s413"): + t = "t413" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n307() + f1n286() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n414(a=414, b=415, c=416.0, s="s414", t="t414", u="u414", p0=828, p1=208.0, p2="p414"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n392() + f1n344() + f1n283() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(24): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(1): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n415(a=415, b=416, c=417.0, s="s415", t="t415"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n268() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(96): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n416(a=416, b=417, c=418.0, s="s416", t="t416", u="u416", p0=832, p1=209.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n313() + f1n385() + f1n295() + f1n394() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(17): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n417(a=417, b=418, c=419.0): + s = "s417" + t = "t417" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n328() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(80): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(87): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n418(): + a = 418 + b = 419 + c = 420.0 + s = "s418" + t = "t418" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n388() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(49): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + return res + +def f1n419(a=419, b=420, c=421.0): + s = "s419" + t = "t419" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n329() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(78): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(39): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + return res + +def f1n420(a=420, b=421, c=422.0, s="s420", t="t420", u="u420", p0=840, p1=211.0, p2="p420", p3=423): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n329() + f1n308() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n421(a=421, b=422, c=423.0, s="s421", t="t421", u="u421", p0=842, p1=211.5, p2="p421", p3=424): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n364() + f1n399() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n422(a=422, b=423, c=424.0, s="s422", t="t422", u="u422", p0=844, p1=212.0, p2="p422"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n364() + f1n343() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(49): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n423(a=423, b=424, c=425.0): + s = "s423" + t = "t423" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n322() + f1n389() + f1n350() + f1n323() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(31): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n424(a=424, b=425, c=426.0, s="s424", t="t424", u="u424", p0=848, p1=213.0, p2="p424"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n298() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n425(a=425, b=426, c=427.0, s="s425", t="t425", u="u425", p0=850, p1=213.5, p2="p425"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n298() + f1n351() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(73): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(81): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n426(a=426, b=427, c=428.0, s="s426", t="t426", u="u426", p0=852, p1=214.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n393() + f1n365() + f1n285() + f1n347() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(36): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(43): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + return res + +def f1n427(a=427): + b = 428 + c = 429.0 + s = "s427" + t = "t427" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n345() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(26): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n428(a=428, b=429, c=430.0, s="s428", t="t428", u="u428"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n318() + f1n322() + f1n398() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + return res + +def f1n429(a=429, b=430, c=431.0, s="s429", t="t429", u="u429", p0=858, p1=215.5, p2="p429"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n391() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(37): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n430(a=430, b=431, c=432.0): + s = "s430" + t = "t430" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n338() + f1n289() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(78): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(68): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n431(a=431, b=432, c=433.0, s="s431", t="t431", u="u431", p0=862, p1=216.5, p2="p431"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n345() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(52): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n432(a=432, b=433, c=434.0, s="s432"): + t = "t432" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n269() + f1n325() + f1n277() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n433(a=433): + b = 434 + c = 435.0 + s = "s433" + t = "t433" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n272() + f1n354() + f1n339() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + return res + +def f1n434(a=434, b=435, c=436.0, s="s434", t="t434"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n362() + f1n365() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(85): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n435(a=435, b=436, c=437.0, s="s435", t="t435", u="u435", p0=870): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n363() + f1n379() + f1n356() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(61): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(8): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + return res + +def f1n436(a=436, b=437, c=438.0, s="s436", t="t436", u="u436", p0=872): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n348() + f1n375() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(62): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n437(): + a = 437 + b = 438 + c = 439.0 + s = "s437" + t = "t437" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n371() + f1n284() + f1n348() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(27): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + return res + +def f1n438(a=438, b=439, c=440.0, s="s438", t="t438", u="u438", p0=876): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n346() + f1n300() + f1n372() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(35): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n439(a=439): + b = 440 + c = 441.0 + s = "s439" + t = "t439" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n361() + f1n371() + f1n292() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(61): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n440(a=440, b=441, c=442.0, s="s440", t="t440", u="u440", p0=880): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n345() + f1n290() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(41): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(16): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + return res + +def f1n441(a=441, b=442, c=443.0, s="s441", t="t441", u="u441", p0=882): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n313() + f1n303() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(12): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(29): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n442(a=442): + b = 443 + c = 444.0 + s = "s442" + t = "t442" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n302() + f1n399() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(67): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n443(a=443, b=444, c=445.0, s="s443", t="t443", u="u443", p0=886, p1=222.5, p2="p443"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n304() + f1n388() + f1n334() + f1n279() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(33): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(70): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + return res + +def f1n444(): + a = 444 + b = 445 + c = 446.0 + s = "s444" + t = "t444" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n376() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(95): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(94): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n445(a=445, b=446, c=447.0, s="s445", t="t445", u="u445", p0=890): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n320() + f1n280() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(93): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + return res + +def f1n446(a=446, b=447, c=448.0, s="s446", t="t446", u="u446", p0=892, p1=224.0, p2="p446"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n396() + f1n311() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(49): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(5): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n447(a=447, b=448, c=449.0, s="s447"): + t = "t447" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n281() + f1n310() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(28): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(4): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v10 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n448(a=448, b=449, c=450.0, s="s448", t="t448", u="u448", p0=896, p1=225.0, p2="p448", p3=451): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n373() + f1n357() + f1n391() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(86): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n449(a=449, b=450, c=451.0, s="s449", t="t449"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n380() + f1n277() + f1n282() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(48): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(64): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + return res + +def f1n450(a=450, b=451, c=452.0, s="s450", t="t450", u="u450", p0=900, p1=226.0, p2="p450", p3=453): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n346() + f1n357() + f1n305() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(49): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n451(a=451, b=452, c=453.0, s="s451", t="t451", u="u451"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n275() + f1n358() + f1n367() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + return res + +def f1n452(a=452, b=453, c=454.0, s="s452", t="t452", u="u452"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n328() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(29): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(77): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + return res + +def f1n453(): + a = 453 + b = 454 + c = 455.0 + s = "s453" + t = "t453" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n352() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(77): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n454(a=454, b=455, c=456.0, s="s454", t="t454", u="u454", p0=908, p1=228.0, p2="p454"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n307() + f1n381() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(54): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(7): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n455(a=455, b=456, c=457.0, s="s455", t="t455", u="u455", p0=910, p1=228.5, p2="p455", p3=458): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n379() + f1n319() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(99): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(47): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(22): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n456(): + a = 456 + b = 457 + c = 458.0 + s = "s456" + t = "t456" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n378() + f1n364() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(23): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n457(a=457, b=458, c=459.0, s="s457", t="t457", u="u457"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n339() + f1n374() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(45): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(83): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + return res + +def f1n458(a=458, b=459, c=460.0, s="s458", t="t458", u="u458", p0=916, p1=230.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n316() + f1n341() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(79): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(24): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(63): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n459(a=459): + b = 460 + c = 461.0 + s = "s459" + t = "t459" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n302() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(40): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(44): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n460(a=460, b=461, c=462.0, s="s460", t="t460", u="u460", p0=920, p1=231.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n275() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(8): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + return res + +def f1n461(a=461, b=462, c=463.0): + s = "s461" + t = "t461" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n353() + f1n301() + f1n390() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(29): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(52): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(60): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n462(a=462, b=463, c=464.0, s="s462", t="t462", u="u462", p0=924): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n284() + f1n349() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(59): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n463(a=463): + b = 464 + c = 465.0 + s = "s463" + t = "t463" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n316() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(66): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n464(a=464, b=465, c=466.0, s="s464", t="t464", u="u464", p0=928, p1=233.0, p2="p464"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n336() + f1n386() + f1n270() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(39): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(69): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(29): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n465(a=465, b=466, c=467.0, s="s465", t="t465"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n313() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(1): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(25): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(18): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n466(a=466, b=467): + c = 468.0 + s = "s466" + t = "t466" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n371() + f1n331() + f1n359() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(11): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(41): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n467(a=467, b=468, c=469.0, s="s467", t="t467", u="u467", p0=934): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n377() + f1n341() + f1n382() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n468(a=468, b=469, c=470.0, s="s468", t="t468", u="u468", p0=936, p1=235.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n273() + f1n294() + f1n327() + f1n321() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(10): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n469(a=469, b=470, c=471.0, s="s469", t="t469", u="u469", p0=938, p1=235.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n276() + f1n390() + f1n278() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n470(a=470, b=471): + c = 472.0 + s = "s470" + t = "t470" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n273() + f1n307() + f1n319() + f1n274() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(71): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(31): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(26): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n471(a=471, b=472, c=473.0, s="s471", t="t471", u="u471"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n385() + f1n302() + f1n359() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(70): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(52): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n472(a=472, b=473, c=474.0): + s = "s472" + t = "t472" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n330() + f1n383() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(90): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(78): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n473(a=473, b=474, c=475.0, s="s473", t="t473", u="u473"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n400() + f1n309() + f1n366() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(85): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(76): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n474(a=474, b=475, c=476.0, s="s474", t="t474", u="u474"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n388() + f1n348() + f1n375() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(47): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n475(a=475, b=476): + c = 477.0 + s = "s475" + t = "t475" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n379() + f1n324() + f1n317() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(69): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + return res + +def f1n476(a=476): + b = 477 + c = 478.0 + s = "s476" + t = "t476" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n384() + f1n356() + f1n396() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(38): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(34): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(34): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n477(a=477, b=478, c=479.0, s="s477", t="t477", u="u477"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n270() + f1n311() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(89): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + return res + +def f1n478(a=478, b=479, c=480.0): + s = "s478" + t = "t478" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n294() + f1n312() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(14): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n479(a=479, b=480, c=481.0, s="s479", t="t479"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n356() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(50): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + return res + +def f1n480(a=480, b=481, c=482.0, s="s480", t="t480", u="u480"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n364() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(74): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(46): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(91): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n481(a=481, b=482, c=483.0, s="s481"): + t = "t481" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n345() + f1n365() + f1n383() + f1n306() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(65): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(60): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(4): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n482(a=482, b=483, c=484.0, s="s482", t="t482", u="u482", p0=964, p1=242.0, p2="p482"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n314() + f1n341() + f1n362() + f1n332() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(55): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(12): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + return res + +def f1n483(a=483, b=484): + c = 485.0 + s = "s483" + t = "t483" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n352() + f1n379() + f1n271() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(83): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(11): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(75): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v4 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n484(a=484, b=485, c=486.0, s="s484", t="t484", u="u484", p0=968, p1=243.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n397() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(42): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(57): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(93): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n485(a=485, b=486, c=487.0, s="s485"): + t = "t485" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n352() + f1n355() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c7 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(96): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v10 - c7) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v1 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v0 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v3 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n486(a=486): + b = 487 + c = 488.0 + s = "s486" + t = "t486" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n386() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(36): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(10): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(63): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j2 * 0.0003 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n487(a=487, b=488, c=489.0, s="s487", t="t487", u="u487", p0=974, p1=244.5, p2="p487"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n328() + f1n363() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(21): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v3 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v5 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w10 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w11 = (v0 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + return res + +def f1n488(a=488, b=489, c=490.0, s="s488", t="t488", u="u488", p0=976, p1=245.0, p2="p488"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n385() + f1n388() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(95): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(42): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(85): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v2 - c4) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + return res + +def f1n489(a=489, b=490, c=491.0): + s = "s489" + t = "t489" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n350() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v11 = (a + 11) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(100): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(97): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + return res + +def f1n490(): + a = 490 + b = 491 + c = 492.0 + s = "s490" + t = "t490" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n385() + f1n291() + f1n297() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(24): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + return res + +def f1n491(a=491, b=492, c=493.0, s="s491", t="t491", u="u491", p0=982, p1=246.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n355() + f1n373() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(52): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(2): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(67): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v1 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n492(a=492, b=493, c=494.0, s="s492", t="t492", u="u492", p0=984, p1=247.0, p2="p492"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n300() + f1n324() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + t5 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(8): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + return res + +def f1n493(a=493, b=494, c=495.0, s="s493", t="t493", u="u493", p0=986, p1=247.5, p2="p493", p3=496): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n339() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c0 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(80): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(52): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j2 in range(27): + acc += (x + j2) * 0.17 + (y - j2 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j2 % 4 == 0: + text2 = text2 + t[-1:] + elif j2 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v4 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v3 + c3) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n494(a=494, b=495, c=496.0, s="s494", t="t494", u="u494", p0=988, p1=248.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n343() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(43): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + return res + +def f1n495(a=495): + b = 496 + c = 497.0 + s = "s495" + t = "t495" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n375() + f1n295() + f1n340() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(74): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v0 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v8 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n496(a=496, b=497, c=498.0, s="s496", t="t496", u="u496", p0=992, p1=249.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n329() + f1n366() + f1n368() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c2 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(8): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(20): + acc += (x + j1) * 0.17 + (y - j1 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + return res + +def f1n497(a=497, b=498, c=499.0): + s = "s497" + t = "t497" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n400() + f1n324() + f1n383() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + c7 = 8.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(32): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + return res + +def f1n498(a=498, b=499, c=500.0, s="s498", t="t498", u="u498", p0=996, p1=250.0, p2="p498", p3=501): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n294() + f1n387() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(66): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + for j1 in range(58): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j1 * 0.0003 + base * 0.0001 + if j1 % 4 == 0: + text2 = text2 + t[-1:] + elif j1 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v6 + c6) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w7 = (v1 - c0) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w8 = (v0 + c1) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w9 = (v3 - c2) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + y = y * 1.0 / 1.0 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + return res + +def f1n499(a=499, b=500, c=501.0, s="s499", t="t499", u="u499"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n333() + f1n303() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + c4 = 5.0 + c5 = 6.0 + c6 = 7.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c4 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c5 * 0.003 + v6 = (a + 6) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c6 * 0.003 + v7 = (a + 7) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v8 = (a + 8) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v9 = (a + 9) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v10 = (a + 10) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c3 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(22): + acc = acc + (a - b) * 0.001 + (x * 0.02) - (y * 0.01) + j0 * 0.0003 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v6 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c4) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v8 - c5) * 0.05 + (a - b) * 0.001 + z * 0.0002 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + y = y * 1.0 / 1.0 + return res + +def f1n500(a=500, b=501, c=502.0, s="s500", t="t500"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1n315() + f1n288() + c0 = 1.0 + c1 = 2.0 + c2 = 3.0 + c3 = 4.0 + v0 = (a + 0) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v1 = (a + 1) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + v2 = (a + 2) * 0.25 + (b - 2) * 0.5 - int(c) * 0.02 + c2 * 0.003 + v3 = (a + 3) * 0.25 + (b - 3) * 0.5 - int(c) * 0.02 + c3 * 0.003 + v4 = (a + 4) * 0.25 + (b - 0) * 0.5 - int(c) * 0.02 + c0 * 0.003 + v5 = (a + 5) * 0.25 + (b - 1) * 0.5 - int(c) * 0.02 + c1 * 0.003 + t0 = (s + ':' + t)[0:] + (s + t)[:0] + t1 = (s + ':' + t)[1:] + (s + t)[:1] + t2 = (s + ':' + t)[2:] + (s + t)[:2] + t3 = (s + ':' + t)[0:] + (s + t)[:0] + t4 = (s + ':' + t)[1:] + (s + t)[:1] + if idx % 2 == 0: + text2 = text2 + s[:1] + elif idx % 3 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k0 = text2.find(t[:1]) + if k0 >= 0: text2 = text2[:k0] + '_' + text2[k0+1:] + for j0 in range(97): + acc += (x + j0) * 0.17 + (y - j0 / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j0 % 4 == 0: + text2 = text2 + t[-1:] + elif j0 % 6 == 0 and len(text2) > 2: + text2 = text2[2:] + text2[:2] + else: + q = text2.find(s[:1]) + if q >= 0: text2 = text2[:q] + '.' + text2[q+1:] + w0 = (v0 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w1 = (v4 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w2 = (v2 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w3 = (v0 - c3) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w4 = (v4 + c0) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + w5 = (v2 - c1) * 0.05 + (a - b) * 0.001 + z * 0.0002 + w6 = (v1 + c2) * 0.07 + (a + b) * 0.001 - int(c) * 0.0005 + m0 = (a - b) * 0.01 + (a + b) * 0.02 - int(c) * 0.001 + text2 = (text2 + s[-1:]) if (idx % 2 == 0) else (text2[1:] + text2[:1]) + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + m0 + len(text2) + idx + base * 0.01 + x = x + 1 - 1 + acc = acc + base * 0.0 + idx = idx + (len(text2) % 3) + idx = idx + (len(text2) % 3) + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + acc = acc + base * 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + base * 0.0 + acc = acc + base * 0.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + x = x + 1 - 1 + x = x + 1 - 1 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + z = z + 0.0 - 0.0 + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + idx = idx + (len(text2) % 3) + x = x + 1 - 1 + x = x + 1 - 1 + acc = acc + (a * 0.001) - (b * 0.0005) + c * 0.0003 + z = z + 0.0 - 0.0 + y = y * 1.0 / 1.0 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + y = y * 1.0 / 1.0 + y = y * 1.0 / 1.0 + text2 = text2 if len(text2) < 3 else (text2[:1] + text2[1:]) + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + x = x + 1 - 1 + idx = idx + (len(text2) % 3) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + m0 = m0 + (acc * 0.00001) - (u0 * 0.000001) + z = z + 0.0 - 0.0 + x = x + 1 - 1 + acc = acc + base * 0.0 + x = x + 1 - 1 + z = z + 0.0 - 0.0 + return res + +def phase1main(): + total = 0.0 + # Direct calls to top-layer entry functions; the rest are reached indirectly + total += f1n401() + f1n402() + f1n403() + f1n404() + f1n405() + total += f1n406() + f1n407() + f1n408() + f1n409() + f1n410() + total += f1n411() + f1n412() + f1n413() + f1n414() + f1n415() + total += f1n416() + f1n417() + f1n418() + f1n419() + f1n420() + total += f1n421() + f1n422() + f1n423() + f1n424() + f1n425() + total += f1n426() + f1n427() + f1n428() + f1n429() + f1n430() + total += f1n431() + f1n432() + f1n433() + f1n434() + f1n435() + total += f1n436() + f1n437() + f1n438() + f1n439() + f1n440() + total += f1n441() + f1n442() + f1n443() + f1n444() + f1n445() + total += f1n446() + f1n447() + f1n448() + f1n449() + f1n450() + total += f1n451() + f1n452() + f1n453() + f1n454() + f1n455() + total += f1n456() + f1n457() + f1n458() + f1n459() + f1n460() + total += f1n461() + f1n462() + f1n463() + f1n464() + f1n465() + total += f1n466() + f1n467() + f1n468() + f1n469() + f1n470() + total += f1n471() + f1n472() + f1n473() + f1n474() + f1n475() + total += f1n476() + f1n477() + f1n478() + f1n479() + f1n480() + total += f1n481() + f1n482() + f1n483() + f1n484() + f1n485() + total += f1n486() + f1n487() + f1n488() + f1n489() + f1n490() + total += f1n491() + f1n492() + f1n493() + f1n494() + f1n495() + total += f1n496() + f1n497() + f1n498() + f1n499() + f1n500() + +def f1(a=1): + b = 2 + c = 3.0 + s = "s1" + t = "t1" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(11): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f2(a=2, b=3): + c = 4.0 + s = "s2" + t = "t2" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(12): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f3(a=3, b=4, c=5.0): + s = "s3" + t = "t3" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(13): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f4(a=4, b=5, c=6.0, s="s4"): + t = "t4" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(14): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f5(a=5, b=6, c=7.0, s="s5", t="t5"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(15): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f6(a=6, b=7, c=8.0, s="s6", t="t6", u="u6"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(16): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f7(a=7, b=8, c=9.0, s="s7", t="t7", u="u7", p0=14): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(17): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f8(a=8, b=9, c=10.0, s="s8", t="t8", u="u8", p0=16, p1=5.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(18): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f9(a=9, b=10, c=11.0, s="s9", t="t9", u="u9", p0=18, p1=5.5, p2="p9"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(19): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f10(a=10, b=11, c=12.0, s="s10", t="t10", u="u10", p0=20, p1=6.0, p2="p10", p3=13): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(20): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f11(): + a = 11 + b = 12 + c = 13.0 + s = "s11" + t = "t11" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(21): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f12(a=12): + b = 13 + c = 14.0 + s = "s12" + t = "t12" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(22): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f13(a=13, b=14): + c = 15.0 + s = "s13" + t = "t13" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(23): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f14(a=14, b=15, c=16.0): + s = "s14" + t = "t14" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(24): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f15(a=15, b=16, c=17.0, s="s15"): + t = "t15" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(25): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f16(a=16, b=17, c=18.0, s="s16", t="t16"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(26): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f17(a=17, b=18, c=19.0, s="s17", t="t17", u="u17"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(27): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f18(a=18, b=19, c=20.0, s="s18", t="t18", u="u18", p0=36): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(28): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f19(a=19, b=20, c=21.0, s="s19", t="t19", u="u19", p0=38, p1=10.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(29): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f20(a=20, b=21, c=22.0, s="s20", t="t20", u="u20", p0=40, p1=11.0, p2="p20"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(30): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f21(a=21, b=22, c=23.0, s="s21", t="t21", u="u21", p0=42, p1=11.5, p2="p21", p3=24): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1() + f1() + for j in range(31): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f22(): + a = 22 + b = 23 + c = 24.0 + s = "s22" + t = "t22" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f2() + f1() + for j in range(32): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f23(a=23): + b = 24 + c = 25.0 + s = "s23" + t = "t23" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f3() + f2() + for j in range(33): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f24(a=24, b=25): + c = 26.0 + s = "s24" + t = "t24" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f4() + f3() + for j in range(34): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f25(a=25, b=26, c=27.0): + s = "s25" + t = "t25" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f5() + f4() + for j in range(35): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f26(a=26, b=27, c=28.0, s="s26"): + t = "t26" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f6() + f5() + for j in range(36): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f27(a=27, b=28, c=29.0, s="s27", t="t27"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f7() + f6() + for j in range(37): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f28(a=28, b=29, c=30.0, s="s28", t="t28", u="u28"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f8() + f7() + for j in range(38): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f29(a=29, b=30, c=31.0, s="s29", t="t29", u="u29", p0=58): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f9() + f8() + for j in range(39): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f30(a=30, b=31, c=32.0, s="s30", t="t30", u="u30", p0=60, p1=16.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f10() + f9() + for j in range(40): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f31(a=31, b=32, c=33.0, s="s31", t="t31", u="u31", p0=62, p1=16.5, p2="p31"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f11() + f10() + for j in range(41): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f32(a=32, b=33, c=34.0, s="s32", t="t32", u="u32", p0=64, p1=17.0, p2="p32", p3=35): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f12() + f11() + for j in range(42): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f33(): + a = 33 + b = 34 + c = 35.0 + s = "s33" + t = "t33" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f13() + f12() + for j in range(43): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f34(a=34): + b = 35 + c = 36.0 + s = "s34" + t = "t34" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f14() + f13() + for j in range(44): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f35(a=35, b=36): + c = 37.0 + s = "s35" + t = "t35" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f15() + f14() + for j in range(45): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f36(a=36, b=37, c=38.0): + s = "s36" + t = "t36" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f16() + f15() + for j in range(46): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f37(a=37, b=38, c=39.0, s="s37"): + t = "t37" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f17() + f16() + for j in range(47): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f38(a=38, b=39, c=40.0, s="s38", t="t38"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f18() + f17() + for j in range(48): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f39(a=39, b=40, c=41.0, s="s39", t="t39", u="u39"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f19() + f18() + for j in range(49): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f40(a=40, b=41, c=42.0, s="s40", t="t40", u="u40", p0=80): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f20() + f19() + for j in range(50): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f41(a=41, b=42, c=43.0, s="s41", t="t41", u="u41", p0=82, p1=21.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f21() + f20() + for j in range(51): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f42(a=42, b=43, c=44.0, s="s42", t="t42", u="u42", p0=84, p1=22.0, p2="p42"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f22() + f21() + for j in range(52): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f43(a=43, b=44, c=45.0, s="s43", t="t43", u="u43", p0=86, p1=22.5, p2="p43", p3=46): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f23() + f22() + for j in range(53): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f44(): + a = 44 + b = 45 + c = 46.0 + s = "s44" + t = "t44" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f24() + f23() + for j in range(54): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f45(a=45): + b = 46 + c = 47.0 + s = "s45" + t = "t45" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f25() + f24() + for j in range(55): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f46(a=46, b=47): + c = 48.0 + s = "s46" + t = "t46" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f26() + f25() + for j in range(56): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f47(a=47, b=48, c=49.0): + s = "s47" + t = "t47" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f27() + f26() + for j in range(57): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f48(a=48, b=49, c=50.0, s="s48"): + t = "t48" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f28() + f27() + for j in range(58): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f49(a=49, b=50, c=51.0, s="s49", t="t49"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f29() + f28() + for j in range(59): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f50(a=50, b=51, c=52.0, s="s50", t="t50", u="u50"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f30() + f29() + for j in range(60): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f51(a=51, b=52, c=53.0, s="s51", t="t51", u="u51", p0=102): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f31() + f30() + for j in range(61): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f52(a=52, b=53, c=54.0, s="s52", t="t52", u="u52", p0=104, p1=27.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f32() + f31() + for j in range(62): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f53(a=53, b=54, c=55.0, s="s53", t="t53", u="u53", p0=106, p1=27.5, p2="p53"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f33() + f32() + for j in range(63): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f54(a=54, b=55, c=56.0, s="s54", t="t54", u="u54", p0=108, p1=28.0, p2="p54", p3=57): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f34() + f33() + for j in range(64): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f55(): + a = 55 + b = 56 + c = 57.0 + s = "s55" + t = "t55" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f35() + f34() + for j in range(65): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f56(a=56): + b = 57 + c = 58.0 + s = "s56" + t = "t56" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f36() + f35() + for j in range(66): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f57(a=57, b=58): + c = 59.0 + s = "s57" + t = "t57" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f37() + f36() + for j in range(67): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f58(a=58, b=59, c=60.0): + s = "s58" + t = "t58" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f38() + f37() + for j in range(68): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f59(a=59, b=60, c=61.0, s="s59"): + t = "t59" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f39() + f38() + for j in range(69): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f60(a=60, b=61, c=62.0, s="s60", t="t60"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f40() + f39() + for j in range(70): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f61(a=61, b=62, c=63.0, s="s61", t="t61", u="u61"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f41() + f40() + for j in range(71): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f62(a=62, b=63, c=64.0, s="s62", t="t62", u="u62", p0=124): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f42() + f41() + for j in range(72): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f63(a=63, b=64, c=65.0, s="s63", t="t63", u="u63", p0=126, p1=32.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f43() + f42() + for j in range(73): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f64(a=64, b=65, c=66.0, s="s64", t="t64", u="u64", p0=128, p1=33.0, p2="p64"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f44() + f43() + for j in range(74): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f65(a=65, b=66, c=67.0, s="s65", t="t65", u="u65", p0=130, p1=33.5, p2="p65", p3=68): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f45() + f44() + for j in range(75): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f66(): + a = 66 + b = 67 + c = 68.0 + s = "s66" + t = "t66" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f46() + f45() + for j in range(76): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f67(a=67): + b = 68 + c = 69.0 + s = "s67" + t = "t67" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f47() + f46() + for j in range(77): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f68(a=68, b=69): + c = 70.0 + s = "s68" + t = "t68" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f48() + f47() + for j in range(78): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f69(a=69, b=70, c=71.0): + s = "s69" + t = "t69" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f49() + f48() + for j in range(79): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f70(a=70, b=71, c=72.0, s="s70"): + t = "t70" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f50() + f49() + for j in range(80): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f71(a=71, b=72, c=73.0, s="s71", t="t71"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f51() + f50() + for j in range(81): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f72(a=72, b=73, c=74.0, s="s72", t="t72", u="u72"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f52() + f51() + for j in range(82): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f73(a=73, b=74, c=75.0, s="s73", t="t73", u="u73", p0=146): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f53() + f52() + for j in range(83): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f74(a=74, b=75, c=76.0, s="s74", t="t74", u="u74", p0=148, p1=38.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f54() + f53() + for j in range(84): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f75(a=75, b=76, c=77.0, s="s75", t="t75", u="u75", p0=150, p1=38.5, p2="p75"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f55() + f54() + for j in range(85): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f76(a=76, b=77, c=78.0, s="s76", t="t76", u="u76", p0=152, p1=39.0, p2="p76", p3=79): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f56() + f55() + for j in range(86): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f77(): + a = 77 + b = 78 + c = 79.0 + s = "s77" + t = "t77" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f57() + f56() + for j in range(87): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f78(a=78): + b = 79 + c = 80.0 + s = "s78" + t = "t78" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f58() + f57() + for j in range(88): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f79(a=79, b=80): + c = 81.0 + s = "s79" + t = "t79" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f59() + f58() + for j in range(89): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f80(a=80, b=81, c=82.0): + s = "s80" + t = "t80" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f60() + f59() + for j in range(90): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f81(a=81, b=82, c=83.0, s="s81"): + t = "t81" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f61() + f60() + for j in range(91): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f82(a=82, b=83, c=84.0, s="s82", t="t82"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f62() + f61() + for j in range(92): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f83(a=83, b=84, c=85.0, s="s83", t="t83", u="u83"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f63() + f62() + for j in range(93): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f84(a=84, b=85, c=86.0, s="s84", t="t84", u="u84", p0=168): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f64() + f63() + for j in range(94): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f85(a=85, b=86, c=87.0, s="s85", t="t85", u="u85", p0=170, p1=43.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f65() + f64() + for j in range(95): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f86(a=86, b=87, c=88.0, s="s86", t="t86", u="u86", p0=172, p1=44.0, p2="p86"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f66() + f65() + for j in range(96): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f87(a=87, b=88, c=89.0, s="s87", t="t87", u="u87", p0=174, p1=44.5, p2="p87", p3=90): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f67() + f66() + for j in range(97): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f88(): + a = 88 + b = 89 + c = 90.0 + s = "s88" + t = "t88" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f68() + f67() + for j in range(98): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f89(a=89): + b = 90 + c = 91.0 + s = "s89" + t = "t89" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f69() + f68() + for j in range(99): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f90(a=90, b=91): + c = 92.0 + s = "s90" + t = "t90" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f70() + f69() + for j in range(10): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f91(a=91, b=92, c=93.0): + s = "s91" + t = "t91" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f71() + f70() + for j in range(11): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f92(a=92, b=93, c=94.0, s="s92"): + t = "t92" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f72() + f71() + for j in range(12): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f93(a=93, b=94, c=95.0, s="s93", t="t93"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f73() + f72() + for j in range(13): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f94(a=94, b=95, c=96.0, s="s94", t="t94", u="u94"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f74() + f73() + for j in range(14): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f95(a=95, b=96, c=97.0, s="s95", t="t95", u="u95", p0=190): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f75() + f74() + for j in range(15): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f96(a=96, b=97, c=98.0, s="s96", t="t96", u="u96", p0=192, p1=49.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f76() + f75() + for j in range(16): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f97(a=97, b=98, c=99.0, s="s97", t="t97", u="u97", p0=194, p1=49.5, p2="p97"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f77() + f76() + for j in range(17): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f98(a=98, b=99, c=100.0, s="s98", t="t98", u="u98", p0=196, p1=50.0, p2="p98", p3=101): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f78() + f77() + for j in range(18): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f99(): + a = 99 + b = 100 + c = 101.0 + s = "s99" + t = "t99" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f79() + f78() + for j in range(19): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f100(a=100): + b = 101 + c = 102.0 + s = "s100" + t = "t100" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f80() + f79() + for j in range(20): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def phase2main(): + total = 0.0 + # Call all 100 functions; arguments use defaults + total += f1() + f2() + f3() + f4() + f5() + total += f6() + f7() + f8() + f9() + f10() + total += f11() + f12() + f13() + f14() + f15() + total += f16() + f17() + f18() + f19() + f20() + total += f21() + f22() + f23() + f24() + f25() + total += f26() + f27() + f28() + f29() + f30() + total += f31() + f32() + f33() + f34() + f35() + total += f36() + f37() + f38() + f39() + f40() + total += f41() + f42() + f43() + f44() + f45() + total += f46() + f47() + f48() + f49() + f50() + total += f51() + f52() + f53() + f54() + f55() + total += f56() + f57() + f58() + f59() + f60() + total += f61() + f62() + f63() + f64() + f65() + total += f66() + f67() + f68() + f69() + f70() + total += f71() + f72() + f73() + f74() + f75() + total += f76() + f77() + f78() + f79() + f80() + total += f81() + f82() + f83() + f84() + f85() + total += f86() + f87() + f88() + f89() + f90() + total += f91() + f92() + f93() + f94() + f95() + total += f96() + f97() + f98() + f99() + f100() + + +def main(): + last200it_time: int = int(datetime.now(timezone.utc).timestamp() * 1000) + phase1it: int = int(sys.argv[1]) + phase2it: int = int(sys.argv[2]) + print("START EXECUTION", flush = True) + for i in range(phase1it): + phase1main() + print("START EXECUTION2", flush = True) + for i in range(phase2it + 200): + if i == phase2it: + print("START MEASURING", flush = True) + last200it_time = int(datetime.now(timezone.utc).timestamp() * 1000) + phase2main() + endtimestamp = int(datetime.now(timezone.utc).timestamp() * 1000) + print(f"LAST_200_IT_TIME = {endtimestamp - last200it_time} ms", flush = True) + +if __name__ == "__main__": + main() + diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script_baseline.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script_baseline.py new file mode 100644 index 0000000000..1a0fc66873 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_script_baseline.py @@ -0,0 +1,2620 @@ +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from datetime import datetime, timezone +import sys + +def f1(a=1): + b = 2 + c = 3.0 + s = "s1" + t = "t1" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(11): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f2(a=2, b=3): + c = 4.0 + s = "s2" + t = "t2" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(12): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f3(a=3, b=4, c=5.0): + s = "s3" + t = "t3" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(13): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f4(a=4, b=5, c=6.0, s="s4"): + t = "t4" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(14): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f5(a=5, b=6, c=7.0, s="s5", t="t5"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(15): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f6(a=6, b=7, c=8.0, s="s6", t="t6", u="u6"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(16): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f7(a=7, b=8, c=9.0, s="s7", t="t7", u="u7", p0=14): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(17): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f8(a=8, b=9, c=10.0, s="s8", t="t8", u="u8", p0=16, p1=5.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(18): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f9(a=9, b=10, c=11.0, s="s9", t="t9", u="u9", p0=18, p1=5.5, p2="p9"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(19): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f10(a=10, b=11, c=12.0, s="s10", t="t10", u="u10", p0=20, p1=6.0, p2="p10", p3=13): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(20): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f11(): + a = 11 + b = 12 + c = 13.0 + s = "s11" + t = "t11" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(21): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f12(a=12): + b = 13 + c = 14.0 + s = "s12" + t = "t12" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(22): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f13(a=13, b=14): + c = 15.0 + s = "s13" + t = "t13" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(23): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f14(a=14, b=15, c=16.0): + s = "s14" + t = "t14" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(24): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f15(a=15, b=16, c=17.0, s="s15"): + t = "t15" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(25): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f16(a=16, b=17, c=18.0, s="s16", t="t16"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(26): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f17(a=17, b=18, c=19.0, s="s17", t="t17", u="u17"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(27): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f18(a=18, b=19, c=20.0, s="s18", t="t18", u="u18", p0=36): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(28): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f19(a=19, b=20, c=21.0, s="s19", t="t19", u="u19", p0=38, p1=10.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(29): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f20(a=20, b=21, c=22.0, s="s20", t="t20", u="u20", p0=40, p1=11.0, p2="p20"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = 0.0 + for j in range(30): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f21(a=21, b=22, c=23.0, s="s21", t="t21", u="u21", p0=42, p1=11.5, p2="p21", p3=24): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f1() + f1() + for j in range(31): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f22(): + a = 22 + b = 23 + c = 24.0 + s = "s22" + t = "t22" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f2() + f1() + for j in range(32): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f23(a=23): + b = 24 + c = 25.0 + s = "s23" + t = "t23" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f3() + f2() + for j in range(33): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f24(a=24, b=25): + c = 26.0 + s = "s24" + t = "t24" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f4() + f3() + for j in range(34): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f25(a=25, b=26, c=27.0): + s = "s25" + t = "t25" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f5() + f4() + for j in range(35): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f26(a=26, b=27, c=28.0, s="s26"): + t = "t26" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f6() + f5() + for j in range(36): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f27(a=27, b=28, c=29.0, s="s27", t="t27"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f7() + f6() + for j in range(37): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f28(a=28, b=29, c=30.0, s="s28", t="t28", u="u28"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f8() + f7() + for j in range(38): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f29(a=29, b=30, c=31.0, s="s29", t="t29", u="u29", p0=58): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f9() + f8() + for j in range(39): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f30(a=30, b=31, c=32.0, s="s30", t="t30", u="u30", p0=60, p1=16.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f10() + f9() + for j in range(40): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f31(a=31, b=32, c=33.0, s="s31", t="t31", u="u31", p0=62, p1=16.5, p2="p31"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f11() + f10() + for j in range(41): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f32(a=32, b=33, c=34.0, s="s32", t="t32", u="u32", p0=64, p1=17.0, p2="p32", p3=35): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f12() + f11() + for j in range(42): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f33(): + a = 33 + b = 34 + c = 35.0 + s = "s33" + t = "t33" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f13() + f12() + for j in range(43): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f34(a=34): + b = 35 + c = 36.0 + s = "s34" + t = "t34" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f14() + f13() + for j in range(44): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f35(a=35, b=36): + c = 37.0 + s = "s35" + t = "t35" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f15() + f14() + for j in range(45): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f36(a=36, b=37, c=38.0): + s = "s36" + t = "t36" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f16() + f15() + for j in range(46): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f37(a=37, b=38, c=39.0, s="s37"): + t = "t37" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f17() + f16() + for j in range(47): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f38(a=38, b=39, c=40.0, s="s38", t="t38"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f18() + f17() + for j in range(48): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f39(a=39, b=40, c=41.0, s="s39", t="t39", u="u39"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f19() + f18() + for j in range(49): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f40(a=40, b=41, c=42.0, s="s40", t="t40", u="u40", p0=80): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f20() + f19() + for j in range(50): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f41(a=41, b=42, c=43.0, s="s41", t="t41", u="u41", p0=82, p1=21.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f21() + f20() + for j in range(51): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f42(a=42, b=43, c=44.0, s="s42", t="t42", u="u42", p0=84, p1=22.0, p2="p42"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f22() + f21() + for j in range(52): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f43(a=43, b=44, c=45.0, s="s43", t="t43", u="u43", p0=86, p1=22.5, p2="p43", p3=46): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f23() + f22() + for j in range(53): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f44(): + a = 44 + b = 45 + c = 46.0 + s = "s44" + t = "t44" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f24() + f23() + for j in range(54): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f45(a=45): + b = 46 + c = 47.0 + s = "s45" + t = "t45" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f25() + f24() + for j in range(55): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f46(a=46, b=47): + c = 48.0 + s = "s46" + t = "t46" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f26() + f25() + for j in range(56): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f47(a=47, b=48, c=49.0): + s = "s47" + t = "t47" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f27() + f26() + for j in range(57): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f48(a=48, b=49, c=50.0, s="s48"): + t = "t48" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f28() + f27() + for j in range(58): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f49(a=49, b=50, c=51.0, s="s49", t="t49"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f29() + f28() + for j in range(59): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f50(a=50, b=51, c=52.0, s="s50", t="t50", u="u50"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f30() + f29() + for j in range(60): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f51(a=51, b=52, c=53.0, s="s51", t="t51", u="u51", p0=102): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f31() + f30() + for j in range(61): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f52(a=52, b=53, c=54.0, s="s52", t="t52", u="u52", p0=104, p1=27.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f32() + f31() + for j in range(62): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f53(a=53, b=54, c=55.0, s="s53", t="t53", u="u53", p0=106, p1=27.5, p2="p53"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f33() + f32() + for j in range(63): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f54(a=54, b=55, c=56.0, s="s54", t="t54", u="u54", p0=108, p1=28.0, p2="p54", p3=57): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f34() + f33() + for j in range(64): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f55(): + a = 55 + b = 56 + c = 57.0 + s = "s55" + t = "t55" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f35() + f34() + for j in range(65): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f56(a=56): + b = 57 + c = 58.0 + s = "s56" + t = "t56" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f36() + f35() + for j in range(66): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f57(a=57, b=58): + c = 59.0 + s = "s57" + t = "t57" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f37() + f36() + for j in range(67): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f58(a=58, b=59, c=60.0): + s = "s58" + t = "t58" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f38() + f37() + for j in range(68): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f59(a=59, b=60, c=61.0, s="s59"): + t = "t59" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f39() + f38() + for j in range(69): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f60(a=60, b=61, c=62.0, s="s60", t="t60"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f40() + f39() + for j in range(70): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f61(a=61, b=62, c=63.0, s="s61", t="t61", u="u61"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f41() + f40() + for j in range(71): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f62(a=62, b=63, c=64.0, s="s62", t="t62", u="u62", p0=124): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f42() + f41() + for j in range(72): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f63(a=63, b=64, c=65.0, s="s63", t="t63", u="u63", p0=126, p1=32.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f43() + f42() + for j in range(73): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f64(a=64, b=65, c=66.0, s="s64", t="t64", u="u64", p0=128, p1=33.0, p2="p64"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f44() + f43() + for j in range(74): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f65(a=65, b=66, c=67.0, s="s65", t="t65", u="u65", p0=130, p1=33.5, p2="p65", p3=68): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f45() + f44() + for j in range(75): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f66(): + a = 66 + b = 67 + c = 68.0 + s = "s66" + t = "t66" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f46() + f45() + for j in range(76): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f67(a=67): + b = 68 + c = 69.0 + s = "s67" + t = "t67" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f47() + f46() + for j in range(77): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f68(a=68, b=69): + c = 70.0 + s = "s68" + t = "t68" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f48() + f47() + for j in range(78): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f69(a=69, b=70, c=71.0): + s = "s69" + t = "t69" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f49() + f48() + for j in range(79): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f70(a=70, b=71, c=72.0, s="s70"): + t = "t70" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f50() + f49() + for j in range(80): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f71(a=71, b=72, c=73.0, s="s71", t="t71"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f51() + f50() + for j in range(81): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f72(a=72, b=73, c=74.0, s="s72", t="t72", u="u72"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f52() + f51() + for j in range(82): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f73(a=73, b=74, c=75.0, s="s73", t="t73", u="u73", p0=146): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f53() + f52() + for j in range(83): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f74(a=74, b=75, c=76.0, s="s74", t="t74", u="u74", p0=148, p1=38.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f54() + f53() + for j in range(84): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f75(a=75, b=76, c=77.0, s="s75", t="t75", u="u75", p0=150, p1=38.5, p2="p75"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f55() + f54() + for j in range(85): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f76(a=76, b=77, c=78.0, s="s76", t="t76", u="u76", p0=152, p1=39.0, p2="p76", p3=79): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f56() + f55() + for j in range(86): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f77(): + a = 77 + b = 78 + c = 79.0 + s = "s77" + t = "t77" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f57() + f56() + for j in range(87): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f78(a=78): + b = 79 + c = 80.0 + s = "s78" + t = "t78" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f58() + f57() + for j in range(88): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f79(a=79, b=80): + c = 81.0 + s = "s79" + t = "t79" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f59() + f58() + for j in range(89): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f80(a=80, b=81, c=82.0): + s = "s80" + t = "t80" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f60() + f59() + for j in range(90): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f81(a=81, b=82, c=83.0, s="s81"): + t = "t81" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f61() + f60() + for j in range(91): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f82(a=82, b=83, c=84.0, s="s82", t="t82"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f62() + f61() + for j in range(92): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f83(a=83, b=84, c=85.0, s="s83", t="t83", u="u83"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f63() + f62() + for j in range(93): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f84(a=84, b=85, c=86.0, s="s84", t="t84", u="u84", p0=168): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f64() + f63() + for j in range(94): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f85(a=85, b=86, c=87.0, s="s85", t="t85", u="u85", p0=170, p1=43.5): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f65() + f64() + for j in range(95): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f86(a=86, b=87, c=88.0, s="s86", t="t86", u="u86", p0=172, p1=44.0, p2="p86"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f66() + f65() + for j in range(96): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f87(a=87, b=88, c=89.0, s="s87", t="t87", u="u87", p0=174, p1=44.5, p2="p87", p3=90): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f67() + f66() + for j in range(97): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f88(): + a = 88 + b = 89 + c = 90.0 + s = "s88" + t = "t88" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f68() + f67() + for j in range(98): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f89(a=89): + b = 90 + c = 91.0 + s = "s89" + t = "t89" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f69() + f68() + for j in range(99): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f90(a=90, b=91): + c = 92.0 + s = "s90" + t = "t90" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f70() + f69() + for j in range(10): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f91(a=91, b=92, c=93.0): + s = "s91" + t = "t91" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f71() + f70() + for j in range(11): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f92(a=92, b=93, c=94.0, s="s92"): + t = "t92" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f72() + f71() + for j in range(12): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f93(a=93, b=94, c=95.0, s="s93", t="t93"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f73() + f72() + for j in range(13): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f94(a=94, b=95, c=96.0, s="s94", t="t94", u="u94"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f74() + f73() + for j in range(14): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f95(a=95, b=96, c=97.0, s="s95", t="t95", u="u95", p0=190): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f75() + f74() + for j in range(15): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f96(a=96, b=97, c=98.0, s="s96", t="t96", u="u96", p0=192, p1=49.0): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f76() + f75() + for j in range(16): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f97(a=97, b=98, c=99.0, s="s97", t="t97", u="u97", p0=194, p1=49.5, p2="p97"): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f77() + f76() + for j in range(17): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f98(a=98, b=99, c=100.0, s="s98", t="t98", u="u98", p0=196, p1=50.0, p2="p98", p3=101): + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f78() + f77() + for j in range(18): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f99(): + a = 99 + b = 100 + c = 101.0 + s = "s99" + t = "t99" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f79() + f78() + for j in range(19): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def f100(a=100): + b = 101 + c = 102.0 + s = "s100" + t = "t100" + u0 = a + b + int(c) + x = (a + b) * 2 - int(c) + y = c * 1.1 + a / (b + 1.0) - 0.01 + z = (a + 2) * (b + 3) - int(c * 0.5) + text = s + '-' + t + idx = text.find(s[:1]) + if idx < 0: idx = 0 + text2 = text[idx:] + text[:idx] + acc = 0.0 + base = f80() + f79() + for j in range(20): + acc += (x + j) * 0.17 + (y - j / 7.0) - (z * 0.003) + (u0 % 7) * 0.01 + base * 0.0001 + if j % 3 == 0: + text2 = text2 + s[:1] + elif j % 5 == 0 and len(text2) > 1: + text2 = text2[1:] + text2[:1] + else: + k = text2.find(t[:1]) + if k >= 0: + text2 = text2[:k] + '_' + text2[k+1:] + res = acc + x * 0.1 + y * 0.2 - z * 0.05 + len(text2) + idx + base * 0.01 + return res + +def phase2main(): + total = 0.0 + # Call all 100 functions; arguments use defaults + total += f1() + f2() + f3() + f4() + f5() + total += f6() + f7() + f8() + f9() + f10() + total += f11() + f12() + f13() + f14() + f15() + total += f16() + f17() + f18() + f19() + f20() + total += f21() + f22() + f23() + f24() + f25() + total += f26() + f27() + f28() + f29() + f30() + total += f31() + f32() + f33() + f34() + f35() + total += f36() + f37() + f38() + f39() + f40() + total += f41() + f42() + f43() + f44() + f45() + total += f46() + f47() + f48() + f49() + f50() + total += f51() + f52() + f53() + f54() + f55() + total += f56() + f57() + f58() + f59() + f60() + total += f61() + f62() + f63() + f64() + f65() + total += f66() + f67() + f68() + f69() + f70() + total += f71() + f72() + f73() + f74() + f75() + total += f76() + f77() + f78() + f79() + f80() + total += f81() + f82() + f83() + f84() + f85() + total += f86() + f87() + f88() + f89() + f90() + total += f91() + f92() + f93() + f94() + f95() + total += f96() + f97() + f98() + f99() + f100() + +def main(): + last200it_time: int = int(datetime.now(timezone.utc).timestamp() * 1000) + phase2it: int = int(sys.argv[1]) + print("START EXECUTION2", flush = True) + for i in range(phase2it + 200): + if i == phase2it: + print("START MEASURING", flush = True) + last200it_time = int(datetime.now(timezone.utc).timestamp() * 1000) + phase2main() + endtimestamp = int(datetime.now(timezone.utc).timestamp() * 1000) + print(f"LAST_200_IT_TIME = {endtimestamp - last200it_time} ms", flush = True) + +if __name__ == "__main__": + main() + diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup.py new file mode 100644 index 0000000000..779de788f9 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup.py @@ -0,0 +1,71 @@ +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +import subprocess, sys, re + + +# This benchmark executes the script phase_shift_script in a subprocess. +# The phase_shift_script script runs in two phases. The first phase runs (phase1it) +# iterations of a certain workflow consisting of a large number of generated functions. +# The second phase runs (phase2it + 200) iterations of a different workflow consisting +# of a large, but approx. 5 times smaller, number of other generated +# functions and measures the sum of the time of the last 200 iterations. +# The better the time the better is the code of the second phase workflow +# warmed up. Since the second phase runs after the first phase, the compilation queue +# is pretty filled up when the second phase starts. This benchmark measures how +# well the compilation queue performs in this situation, which can be compared +# with the phase_shift_warmup_baseline benchmark, where the same workflow starts +# with a clean compilation queue. +def __benchmark__(phase1it=0, phase2it=0): + orig_vm_argv = sys.orig_argv + for i, arg in enumerate(orig_vm_argv): + if arg.endswith('harness.py'): + orig_vm_argv = orig_vm_argv[:i] + break + tt: int = 0 + result = subprocess.run([*orig_vm_argv, + "--experimental-options", + "--engine.CompilerThreads=1", + re.sub(r'harness\.py', "micro/phase_shift_script.py", sys.argv[0]), str(phase1it), str(phase2it)], capture_output=True, text=True, check=False) + m = re.search(r"LAST_200_IT_TIME = (\d+) ms", result.stdout) + if m: + tt = int(m.group(1)) + return tt * 1000000 + diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup_baseline.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup_baseline.py new file mode 100644 index 0000000000..0b2f77552a --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/phase_shift_warmup_baseline.py @@ -0,0 +1,67 @@ +# Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +import subprocess, sys, re + + +# This benchmark computes the best possible result of the phase_shift_warmup +# benchmark. It executes the script phase_shift_script_baseline in a subprocess. +# The phase_shift_script_baseline script runs only the second phase of the +# full script phase_shift_script, and so the second phase starts with a clean +# compilation queue. The second phase runs (phase2it + 200) iterations of a +# certain workflow consisting of a large number of generated functions and measures +# the sum of the time of the last 200 iterations. The better the time the better +# is the code of the tested workflow warmed up. +def __benchmark__(phase2it=0): + orig_vm_argv = sys.orig_argv + for i, arg in enumerate(orig_vm_argv): + if arg.endswith('harness.py'): + orig_vm_argv = orig_vm_argv[:i] + break + tt: int = 0 + result = subprocess.run([*orig_vm_argv, + "--experimental-options", + "--engine.CompilerThreads=1", + re.sub(r'harness\.py', "micro/phase_shift_script_baseline.py", sys.argv[0]), str(phase2it)], capture_output=True, text=True, check=False) + m = re.search(r"LAST_200_IT_TIME = (\d+) ms", result.stdout) + if m: + tt = int(m.group(1)) + print(result.stdout) + return tt * 1000000 diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/LICENSE.txt b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/LICENSE.txt new file mode 100644 index 0000000000..fee212f6a3 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/LICENSE.txt @@ -0,0 +1,20 @@ +The MIT License + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/OWNERS.toml b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/OWNERS.toml new file mode 100644 index 0000000000..34cb11f338 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "*" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/README.md b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/README.md new file mode 100644 index 0000000000..44501438e4 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/README.md @@ -0,0 +1,1234 @@ +# Pyperformance benchmark port process for benchmarking with the PolyBench harness + +## Brief explanation + +These benchmarks have been copied from the pyperformance repository and manually updated +so that they conform to the PolyBench contract and they don't use any pyperformance/pyperf interface. +* Remove the usage of `pyperf.Runner` and other `pyperf` functions/classes. +* Move the benchmark workload into the `run` function. +* Define the PolyBench benchmark configuration functions, such as: +`setup`, `warmupIterations`, `iterations`, `summary`, and `dependencies`. + +## Version information + +Version: 1.0.6 +Source repository: Acquired with `pip install` (GitHub repo: https://github.com/python/pyperformance/tree/main) + +The version was chosen to align with the one used in `graalpython/mx.graalpython/mx_graalpython_python_benchmarks.py::PyPerformanceSuite`. + +## Files sourced from the pyperformance project + +The benchmarks from the pyperformance repository have the following characteristics +which do not align with the requirements of the PolyBench harness: +* The benchmark workload is in a `if __name__ == "__main__":` branch. + * The PolyBench harness expects the benchmark workload to be in the `run` function. +* The workload is passed to a `pyperf.Runner` instance for execution. + * The PolyBench harness should execute the workload directly. +* The benchmark has a dependency on `pyperf` for performance measurement purposes. This dependency +is not required for the workload itself. + * As these dependencies are not essential for the workload but used for auxiliary purposes of the + pyperformance harness, they should be eliminated in facilitating benchmarking with the PolyBench harness. + +Additionally, there are special functions that the benchmark may implement to configure the PolyBench execution, +such as: `setup`, `run`, `warmupIterations`, `iterations`, `summary`, and `dependencies`. + +To handle these differences, appropriate changes to the source code of the benchmarks must be made. +These changes are not easy to automate and have therefore been made manually. +The differences have been catalogued in this section, on a file-by-file basis. + +### bm_pathlib.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_pathlib/run_benchmark.py +The file has not been named `pathlib.py` as this name would've hidden the `pathlib` package from the standard library. +Changes made to the original file, as reported by the `diff` tool: +``` +11d10 +< import shutil +14,15d12 +< import pyperf +< +29c26,28 +< def setup(num_files): +--- +> tmp_path = None +> def setup(): +> global tmp_path +31c30 +< for fn in generate_filenames(tmp_path, num_files): +--- +> for fn in generate_filenames(tmp_path, NUM_FILES): +35,36d33 +< return tmp_path +< +49d45 +< t0 = pyperf.perf_counter() +62c58,68 +< return pyperf.perf_counter() - t0 +--- +> +> def run(): +> bench_pathlib(8, tmp_path) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +65,77c71,76 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = ("Test the performance of " +< "pathlib operations.") +< +< modname = pathlib.__name__ +< runner.metadata['pathlib_module'] = modname +< +< tmp_path = setup(NUM_FILES) +< try: +< runner.bench_time_func('pathlib', bench_pathlib, tmp_path) +< finally: +< shutil.rmtree(tmp_path) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### bm_pickle.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_pickle/run_benchmark.py +The file has not been named `pickle.py` as this name would've hidden the `pickle` package from the standard library. +Changes made to the original file, as reported by the `diff` tool: +``` +18,20c18,19 +< +< import pyperf +< IS_PYPY = (pyperf.python_implementation() == 'pypy') +--- +> import argparse +> import pickle +87d85 +< t0 = pyperf.perf_counter() +113,114d110 +< return pyperf.perf_counter() - t0 +< +126d121 +< t0 = pyperf.perf_counter() +151,152d145 +< return pyperf.perf_counter() - t0 +< +163d155 +< t0 = pyperf.perf_counter() +178,179d169 +< return pyperf.perf_counter() - t0 +< +187d176 +< t0 = pyperf.perf_counter() +202,203d190 +< return pyperf.perf_counter() - t0 +< +213d199 +< t0 = pyperf.perf_counter() +223,224d208 +< return pyperf.perf_counter() - t0 +< +250,252c234,236 +< if __name__ == "__main__": +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = "Test the performance of pickling." +--- +> def run(): +> __benchmark__(["pickle"]) +> +254c238,239 +< parser = runner.argparser +--- +> def __benchmark__(args): +> parser = argparse.ArgumentParser(prog="python") +262,263c247,248 +< options = runner.parse_args() +< benchmark, inner_loops = BENCHMARKS[options.benchmark] +--- +> options = parser.parse_args(args) +> benchmark, _ = BENCHMARKS[options.benchmark] +269c254 +< if not (options.pure_python or IS_PYPY): +--- +> if not options.pure_python: +282,283d266 +< runner.metadata['pickle_protocol'] = str(options.protocol) +< runner.metadata['pickle_module'] = pickle.__name__ +285,286c268,287 +< runner.bench_time_func(name, benchmark, +< pickle, options, inner_loops=inner_loops) +--- +> benchmark(512, pickle, options) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +> +> if __name__ == "__main__": +> run() +``` + +### bm_richards.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_richards/run_benchmark.py +The file has not been named `richards.py` as there is already a `richards.py` in micro benchmarks. +Changes made to the original file, as reported by the `diff` tool: +``` +12,13d11 +< import pyperf +< +418,421c416 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "The Richards benchmark" +< +--- +> def run(): +423c418,434 +< runner.bench_func('richards', richard.run, 1) +--- +> richard.run(1) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### chaos.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_chaos/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +8,9c8 +< +< import pyperf +--- +> import argparse +238c237 +< def main(runner, args): +--- +> def __benchmark__(args): +263,268d261 +< runner.metadata['chaos_thickness'] = args.thickness +< runner.metadata['chaos_width'] = args.width +< runner.metadata['chaos_height'] = args.height +< runner.metadata['chaos_iterations'] = args.iterations +< runner.metadata['chaos_rng_seed'] = args.rng_seed +< +270,272c263 +< runner.bench_func('chaos', chaos.create_image_chaos, +< args.width, args.height, args.iterations, +< args.filename, args.rng_seed) +--- +> chaos.create_image_chaos(args.width, args.height, args.iterations, args.filename, args.rng_seed) +284,287c275,276 +< if __name__ == "__main__": +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = "Create chaosgame-like fractals" +< cmd = runner.argparser +--- +> def run(): +> cmd = argparse.ArgumentParser(prog="python") +308,309c297,314 +< args = runner.parse_args() +< main(runner, args) +--- +> args = cmd.parse_args() +> __benchmark__(args) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### fannkuch.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_fannkuch/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +8,9d7 +< import pyperf +< +51,54c49,66 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< arg = DEFAULT_ARG +< runner.bench_func('fannkuch', fannkuch, arg) +--- +> def run(): +> fannkuch(DEFAULT_ARG) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### float.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_float/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +4,5d3 +< import pyperf +< +55,57c53,63 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "Float benchmark" +--- +> def run(): +> benchmark(POINTS) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +59,60c65,70 +< points = POINTS +< runner.bench_func('float', benchmark, points) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### go.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_go/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +7,8d6 +< import pyperf +< +454,461c452,469 +< if __name__ == "__main__": +< kw = {} +< if pyperf.python_has_jit(): +< # PyPy needs to compute more warmup values to warmup its JIT +< kw['warmups'] = 50 +< runner = pyperf.Runner(**kw) +< runner.metadata['description'] = "Test the performance of the Go benchmark" +< runner.bench_func('go', versus_cpu) +--- +> def run(): +> versus_cpu() +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### hexiom.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_hexiom/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +12,13c12 +< +< import pyperf +--- +> import argparse +621c620 +< def main(loops, level): +--- +> def __benchmark__(loops, level): +631d629 +< t0 = pyperf.perf_counter() +639,640d636 +< dt = pyperf.perf_counter() - t0 +< +646,647d641 +< return dt +< +653,658c647 +< if __name__ == "__main__": +< kw = {'add_cmdline_args': add_cmdline_args} +< if pyperf.python_has_jit(): +< # PyPy needs to compute more warmup values to warmup its JIT +< kw['warmups'] = 15 +< runner = pyperf.Runner(**kw) +--- +> def run(): +660c649,650 +< runner.argparser.add_argument("--level", type=int, +--- +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("--level", type=int, +666,668c656,666 +< args = runner.parse_args() +< runner.metadata['description'] = "Solver of Hexiom board game" +< runner.metadata['hexiom_level'] = args.level +--- +> args = parser.parse_args() +> __benchmark__(16, args.level) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +670c668,673 +< runner.bench_time_func('hexiom', main, args.level) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### json_dumps.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_json_dumps/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +3,4c3 +< +< import pyperf +--- +> import argparse +30,32c29,31 +< def main(): +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.argparser.add_argument("--cases", +--- +> def run(): +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("--cases", +35d33 +< runner.metadata['description'] = "Benchmark json.dumps()" +37c35 +< args = runner.parse_args() +--- +> args = parser.parse_args() +55c53,61 +< runner.bench_func('json_dumps', bench_json_dumps, data) +--- +> bench_json_dumps(data) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +58,59c64,69 +< if __name__ == '__main__': +< main() +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### json_loads.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_json_loads/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +14,16d13 +< # Local imports +< import pyperf +< +97,100c94 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "Benchmark json.loads()" +< +--- +> def run(): +104a99,108 +> bench_json_loads(objs) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +106c110,115 +< runner.bench_func('json_loads', bench_json_loads, objs, inner_loops=20) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### meteor_contest.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_meteor_contest/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +13,14d12 +< import pyperf +< +194d191 +< t0 = pyperf.perf_counter() +204,205d200 +< dt = pyperf.perf_counter() - t0 +< +209,214d203 +< return dt +< +< +< def main(): +< runner = pyperf.Runner() +< runner.metadata['description'] = "Solver for Meteor Puzzle board" +215a205 +> def __benchmark__(): +221,222c211,223 +< runner.bench_time_func('meteor_contest', bench_meteor_contest, +< board, pieces, solve_arg, fps, se_nh) +--- +> bench_meteor_contest(1, board, pieces, solve_arg, fps, se_nh) +> +> +> def run(): +> __benchmark__() +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +225,226c226,231 +< if __name__ == "__main__": +< main() +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### nbody.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_nbody/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +17c17 +< import pyperf +--- +> import argparse +128d127 +< t0 = pyperf.perf_counter() +135,136d133 +< return pyperf.perf_counter() - t0 +< +142,145c139,141 +< if __name__ == '__main__': +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = "n-body benchmark" +< runner.argparser.add_argument("--iterations", +--- +> def run(): +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("--iterations", +149c145 +< runner.argparser.add_argument("--reference", +--- +> parser.add_argument("--reference", +154,156c150,167 +< args = runner.parse_args() +< runner.bench_time_func('nbody', bench_nbody, +< args.reference, args.iterations) +--- +> args = parser.parse_args() +> bench_nbody(1, args.reference, args.iterations) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### nqueens.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_nqueens/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +3,4d2 +< import pyperf +< +57,59c55,65 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "Simple, brute-force N-Queens solver" +--- +> def run(): +> bench_n_queens(8) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +61,62c67,72 +< queen_count = 8 +< runner.bench_func('nqueens', bench_n_queens, queen_count) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### pidigits.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_pidigits/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +12,13c12 +< +< import pyperf +--- +> import argparse +59,62c58,59 +< if __name__ == "__main__": +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< +< cmd = runner.argparser +--- +> def run(): +> cmd = argparse.ArgumentParser(prog="python") +67,70c64,81 +< args = runner.parse_args() +< runner.metadata['description'] = "Compute digits of pi." +< runner.metadata['pidigits_ndigit'] = args.digits +< runner.bench_func('pidigits', calc_ndigits, args.digits) +--- +> args = cmd.parse_args() +> calc_ndigits(args.digits) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### pyflate.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_pyflate/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +23,24d22 +< import pyperf +< +635d632 +< t0 = pyperf.perf_counter() +650d646 +< dt = pyperf.perf_counter() - t0 +656,661d651 +< return dt +< +< +< if __name__ == '__main__': +< runner = pyperf.Runner() +< runner.metadata['description'] = "Pyflate benchmark" +662a653 +> def run(): +665c656,676 +< runner.bench_time_func('pyflate', bench_pyflake, filename) +--- +> bench_pyflake(1, filename) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +> +> +> def dependencies(): +> return ["data/interpreter.tar.bz2"] +``` + +### regex_compile.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_regex_compile/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +11,13c11,12 +< +< # Local imports +< import pyperf +--- +> import sys +> import os +39,40c38,40 +< import bm_regex_effbot +< bm_regex_effbot.bench_regex_effbot(1) +--- +> sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +> import regex_effbot +> regex_effbot.bench_regex_effbot(1) +42,43c42,43 +< import bm_regex_v8 +< bm_regex_v8.bench_regex_v8(1) +--- +> import regex_v8 +> regex_v8.bench_regex_v8(1) +53d52 +< t0 = pyperf.perf_counter() +61d59 +< return pyperf.perf_counter() - t0 +62a61,63 +> def run(): +> regexes = capture_regexes() +> bench_regex_compile(1, regexes) +64,66d64 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "Test regex compilation performance" +68,69c66,83 +< regexes = capture_regexes() +< runner.bench_time_func('regex_compile', bench_regex_compile, regexes) +--- +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +> +> +> def dependencies(): +> return ["regex_effbot.py", "regex_v8.py"] +``` + +### regex_dna.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_regex_dna/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +20,21c20 +< +< import pyperf +--- +> import argparse +189d187 +< t0 = pyperf.perf_counter() +194d191 +< dt = pyperf.perf_counter() - t0 +198,199d194 +< return dt +< +206,212c201,202 +< if __name__ == '__main__': +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = ("Test the performance of regexps " +< "using benchmarks from " +< "The Computer Language Benchmarks Game.") +< +< cmd = runner.argparser +--- +> def run(): +> cmd = argparse.ArgumentParser(prog="python") +220c210 +< args = runner.parse_args() +--- +> args = cmd.parse_args() +229,231d218 +< runner.metadata['regex_dna_fasta_len'] = args.fasta_length +< runner.metadata['regex_dna_rng_seed'] = args.rng_seed +< +236c223,239 +< runner.bench_time_func('regex_dna', bench_regex_dna, seq, expected_res) +--- +> bench_regex_dna(1, seq, expected_res) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### regex_effbot.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_regex_effbot/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +16,18c16 +< +< # Local imports +< import pyperf +--- +> import argparse +135d132 +< t0 = pyperf.perf_counter() +152,153d148 +< return pyperf.perf_counter() - t0 +< +164,168c159,161 +< if __name__ == '__main__': +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = ("Test the performance of regexps " +< "using Fredik Lundh's benchmarks.") +< runner.argparser.add_argument("-B", "--force_bytes", action="store_true", +--- +> def run(): +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("-B", "--force_bytes", action="store_true", +170c163 +< options = runner.parse_args() +--- +> options = parser.parse_args() +174,175c167,183 +< runner.bench_time_func('regex_effbot', bench_regex_effbot, +< inner_loops=10) +--- +> bench_regex_effbot(4) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### regex_v8.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_regex_v8/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +45,47d44 +< # Third party imports +< import pyperf +< +1769d1765 +< t0 = pyperf.perf_counter() +1783d1778 +< return pyperf.perf_counter() - t0 +1786,1790c1781,1798 +< if __name__ == '__main__': +< runner = pyperf.Runner() +< runner.metadata['description'] = ("Test the performance of regexps " +< "using V8's benchmarks") +< runner.bench_time_func('regex_v8', bench_regex_v8) +--- +> def run(): +> bench_regex_v8(8) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### scimark.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_scimark/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +3,4c3 +< +< import pyperf +--- +> import argparse +155d153 +< t0 = pyperf.perf_counter() +161,162d158 +< return pyperf.perf_counter() - t0 +< +166d161 +< t0 = pyperf.perf_counter() +175,176d169 +< return pyperf.perf_counter() - t0 +< +214d206 +< t0 = pyperf.perf_counter() +219,220d210 +< return pyperf.perf_counter() - t0 +< +263d252 +< t0 = pyperf.perf_counter() +268,269d256 +< return pyperf.perf_counter() - t0 +< +375d361 +< t0 = pyperf.perf_counter() +383,384d368 +< return pyperf.perf_counter() - t0 +< +393,397c377,381 +< 'sor': (bench_SOR, 100, 10, Array2D), +< 'sparse_mat_mult': (bench_SparseMatMult, 1000, 50 * 1000), +< 'monte_carlo': (bench_MonteCarlo, 100 * 1000,), +< 'lu': (bench_LU, 100,), +< 'fft': (bench_FFT, 1024, 50), +--- +> 'sor': (bench_SOR, 1, 100, 1, Array2D), +> 'sparse_mat_mult': (bench_SparseMatMult, 4, 1000, 50 * 1000), +> 'monte_carlo': (bench_MonteCarlo, 2, 10 * 1000,), +> 'lu': (bench_LU, 1, 50,), +> 'fft': (bench_FFT, 1, 1024, 5), +401,403c385,387 +< if __name__ == "__main__": +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.argparser.add_argument("benchmark", nargs='?', +--- +> def run(): +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("benchmark", nargs='?', +406c390 +< args = runner.parse_args() +--- +> args = parser.parse_args() +413,415c397,414 +< name = 'scimark_%s' % bench +< args = BENCHMARKS[bench] +< runner.bench_time_func(name, *args) +--- +> func, *func_args = BENCHMARKS[bench] +> func(*func_args) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### spectral_norm.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_spectral_norm/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +15,16d14 +< import pyperf +< +51d48 +< t0 = pyperf.perf_counter() +66c63,73 +< return pyperf.perf_counter() - t0 +--- +> +> def run(): +> bench_spectral_norm(1) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +69,74c76,81 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = ( +< 'MathWorld: "Hundred-Dollar, Hundred-Digit Challenge Problems", ' +< 'Challenge #3.') +< runner.bench_time_func('spectral_norm', bench_spectral_norm) +--- +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### telco.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_telco/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +23,24d22 +< import pyperf +< +44d41 +< start = pyperf.perf_counter() +81d77 +< return pyperf.perf_counter() - start +82a79,81 +> def run(): +> filename = rel_path("data", "telco-bench.b") +> bench_telco(1, filename) +84,86d82 +< if __name__ == "__main__": +< runner = pyperf.Runner() +< runner.metadata['description'] = "Telco decimal benchmark" +88,89c84,101 +< filename = rel_path("data", "telco-bench.b") +< runner.bench_time_func('telco', bench_telco, filename) +--- +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +> +> +> def dependencies(): +> return ["data/telco-bench.b"] +``` + +### unpack_sequence.py +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_unpack_sequence/run_benchmark.py +Changes made to the original file, as reported by the `diff` tool: +``` +3c3 +< import pyperf +--- +> import argparse +8d7 +< t0 = pyperf.perf_counter() +413,414d411 +< return pyperf.perf_counter() - t0 +< +418c415 +< return do_unpacking(loops, x) +--- +> do_unpacking(loops, x) +424c421 +< return do_unpacking(loops, x) +--- +> do_unpacking(loops, x) +428,430c425,426 +< dt1 = bench_tuple_unpacking(loops) +< dt2 = bench_list_unpacking(loops) +< return dt1 + dt2 +--- +> bench_tuple_unpacking(loops) +> bench_list_unpacking(loops) +438c434 +< if __name__ == "__main__": +--- +> def run(): +442,446c438,439 +< runner = pyperf.Runner(add_cmdline_args=add_cmdline_args) +< runner.metadata['description'] = ("Microbenchmark for " +< "Python's sequence unpacking.") +< +< runner.argparser.add_argument("benchmark", nargs="?", +--- +> parser = argparse.ArgumentParser(prog="python") +> parser.add_argument("benchmark", nargs="?", +449c442 +< options = runner.parse_args() +--- +> options = parser.parse_args() +457c450,466 +< runner.bench_time_func(name, func, inner_loops=400) +--- +> func(8192) +> +> +> def warmupIterations(): +> return 0 +> +> +> def iterations(): +> return 10 +> +> +> def summary(): +> return { +> "name": "OutlierRemovalAverageSummary", +> "lower-threshold": 0.0, +> "upper-threshold": 1.0, +> } +``` + +### data/interpreter.tar.bz2 +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_pyflate/data/interpreter.tar.bz2 +Data file used for the `pyflate.py` benchmark. +No modifications made. + +### data/telco-bench.b +Original file path: pyperformance/pyperformance/data-files/benchmarks/bm_telco/data/telco-bench.b +Data file used for the `telco.py` benchmark. +No modifications made. + +## Original files necessary for benchmarking with the PolyBench harness + +These are new files that do not have a corresponding match in the numpy repository. +These files are generated to conform to the expectations of the PolyBench harness. + +### pickle_dict.py +Invokes the benchmark implemented in `bm_pickle.py` with the `["pickle_dict"]` argument value. +This file is the PolyBench equivalent of the pyperformance benchmark variant defined in the +`pyperformance/pyperformance/data-files/benchmarks/bm_pickle/bm_pickle_dict.toml` file. + +### pickle_list.py +Invokes the benchmark implemented in `bm_pickle.py` with the `["pickle_list"]` argument value. +This file is the PolyBench equivalent of the pyperformance benchmark variant defined in the +`pyperformance/pyperformance/data-files/benchmarks/bm_pickle/bm_pickle_list.toml` file. + +### unpickle_list.py +Invokes the benchmark implemented in `bm_pickle.py` with the `["unpickle_list"]` argument value. +This file is the PolyBench equivalent of the pyperformance benchmark variant defined in the +`pyperformance/pyperformance/data-files/benchmarks/bm_pickle/bm_unpickle_list.toml` file. + +### unpickle.py +Invokes the benchmark implemented in `bm_pickle.py` with the `["unpickle"]` argument value. +This file is the PolyBench equivalent of the pyperformance benchmark variant defined in the +`pyperformance/pyperformance/data-files/benchmarks/bm_pickle/bm_unpickle.toml` file. diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pathlib.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pathlib.py new file mode 100644 index 0000000000..ec7f2e01cd --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pathlib.py @@ -0,0 +1,76 @@ +""" +Test the performance of pathlib operations. + +This benchmark stresses the creation of small objects, globbing, and system +calls. +""" + +# Python imports +import os +import pathlib +import tempfile + + +NUM_FILES = 2000 + + +def generate_filenames(tmp_path, num_files): + i = 0 + while num_files: + for ext in [".py", ".txt", ".tar.gz", ""]: + i += 1 + yield os.path.join(tmp_path, str(i) + ext) + num_files -= 1 + + +tmp_path = None +def setup(): + global tmp_path + tmp_path = tempfile.mkdtemp() + for fn in generate_filenames(tmp_path, NUM_FILES): + with open(fn, "wb") as f: + f.write(b'benchmark') + + +def bench_pathlib(loops, tmp_path): + base_path = pathlib.Path(tmp_path) + + # Warm up the filesystem cache and keep some objects in memory. + path_objects = list(base_path.iterdir()) + # FIXME: does this code really cache anything? + for p in path_objects: + p.stat() + assert len(path_objects) == NUM_FILES, len(path_objects) + + range_it = range(loops) + + for _ in range_it: + # Do something simple with each path. + for p in base_path.iterdir(): + p.stat() + for p in base_path.glob("*.py"): + p.stat() + for p in base_path.iterdir(): + p.stat() + for p in base_path.glob("*.py"): + p.stat() + + +def run(): + bench_pathlib(8, tmp_path) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pickle.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pickle.py new file mode 100644 index 0000000000..d4ec077eb6 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_pickle.py @@ -0,0 +1,287 @@ + +"""Script for testing the performance of pickling/unpickling. + +This will pickle/unpickle several real world-representative objects a few +thousand times. The methodology below was chosen for was chosen to be similar +to real-world scenarios which operate on single objects at a time. Note that if +we did something like + + pickle.dumps([dict(some_dict) for _ in range(10000)]) + +this isn't equivalent to dumping the dict 10000 times: pickle uses a +highly-efficient encoding for the n-1 following copies. +""" + +import datetime +import random +import sys +import argparse +import pickle + +__author__ = "collinwinter@google.com (Collin Winter)" + + +DICT = { + 'ads_flags': 0, + 'age': 18, + 'birthday': datetime.date(1980, 5, 7), + 'bulletin_count': 0, + 'comment_count': 0, + 'country': 'BR', + 'encrypted_id': 'G9urXXAJwjE', + 'favorite_count': 9, + 'first_name': '', + 'flags': 412317970704, + 'friend_count': 0, + 'gender': 'm', + 'gender_for_display': 'Male', + 'id': 302935349, + 'is_custom_profile_icon': 0, + 'last_name': '', + 'locale_preference': 'pt_BR', + 'member': 0, + 'tags': ['a', 'b', 'c', 'd', 'e', 'f', 'g'], + 'profile_foo_id': 827119638, + 'secure_encrypted_id': 'Z_xxx2dYx3t4YAdnmfgyKw', + 'session_number': 2, + 'signup_id': '201-19225-223', + 'status': 'A', + 'theme': 1, + 'time_created': 1225237014, + 'time_updated': 1233134493, + 'unread_message_count': 0, + 'user_group': '0', + 'username': 'collinwinter', + 'play_count': 9, + 'view_count': 7, + 'zip': ''} + +TUPLE = ( + [265867233, 265868503, 265252341, 265243910, 265879514, + 266219766, 266021701, 265843726, 265592821, 265246784, + 265853180, 45526486, 265463699, 265848143, 265863062, + 265392591, 265877490, 265823665, 265828884, 265753032], 60) + + +def mutate_dict(orig_dict, random_source): + new_dict = dict(orig_dict) + for key, value in new_dict.items(): + rand_val = random_source.random() * sys.maxsize + if isinstance(key, (int, bytes, str)): + new_dict[key] = type(key)(rand_val) + return new_dict + + +random_source = random.Random(5) # Fixed seed. +DICT_GROUP = [mutate_dict(DICT, random_source) for _ in range(3)] + + +def bench_pickle(loops, pickle, options): + range_it = range(loops) + + # micro-optimization: use fast local variables + dumps = pickle.dumps + objs = (DICT, TUPLE, DICT_GROUP) + protocol = options.protocol + + for _ in range_it: + for obj in objs: + # 20 dumps + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + + +def bench_unpickle(loops, pickle, options): + pickled_dict = pickle.dumps(DICT, options.protocol) + pickled_tuple = pickle.dumps(TUPLE, options.protocol) + pickled_dict_group = pickle.dumps(DICT_GROUP, options.protocol) + range_it = range(loops) + + # micro-optimization: use fast local variables + loads = pickle.loads + objs = (pickled_dict, pickled_tuple, pickled_dict_group) + + for _ in range_it: + for obj in objs: + # 20 loads dict + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + loads(obj) + + +LIST = [[list(range(10)), list(range(10))] for _ in range(10)] + + +def bench_pickle_list(loops, pickle, options): + range_it = range(loops) + # micro-optimization: use fast local variables + dumps = pickle.dumps + obj = LIST + protocol = options.protocol + + for _ in range_it: + # 10 dumps list + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + dumps(obj, protocol) + + +def bench_unpickle_list(loops, pickle, options): + pickled_list = pickle.dumps(LIST, options.protocol) + range_it = range(loops) + + # micro-optimization: use fast local variables + loads = pickle.loads + + for _ in range_it: + # 10 loads list + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + loads(pickled_list) + + +MICRO_DICT = dict((key, dict.fromkeys(range(10))) for key in range(100)) + + +def bench_pickle_dict(loops, pickle, options): + range_it = range(loops) + # micro-optimization: use fast local variables + protocol = options.protocol + obj = MICRO_DICT + + for _ in range_it: + # 5 dumps dict + pickle.dumps(obj, protocol) + pickle.dumps(obj, protocol) + pickle.dumps(obj, protocol) + pickle.dumps(obj, protocol) + pickle.dumps(obj, protocol) + + +BENCHMARKS = { + # 20 inner-loops: don't count the 3 pickled objects + 'pickle': (bench_pickle, 20), + + # 20 inner-loops: don't count the 3 unpickled objects + 'unpickle': (bench_unpickle, 20), + + 'pickle_list': (bench_pickle_list, 10), + 'unpickle_list': (bench_unpickle_list, 10), + 'pickle_dict': (bench_pickle_dict, 5), +} + + +def is_accelerated_module(module): + return getattr(pickle.Pickler, '__module__', '') != 'pickle' + + +def add_cmdline_args(cmd, args): + if args.pure_python: + cmd.append("--pure-python") + cmd.extend(("--protocol", str(args.protocol))) + cmd.append(args.benchmark) + + +def run(): + __benchmark__(["pickle"]) + + +def __benchmark__(args): + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("--pure-python", action="store_true", + help="Use the C version of pickle.") + parser.add_argument("--protocol", action="store", default=None, type=int, + help="Which protocol to use (default: highest protocol).") + benchmarks = sorted(BENCHMARKS) + parser.add_argument("benchmark", choices=benchmarks) + + options = parser.parse_args(args) + benchmark, _ = BENCHMARKS[options.benchmark] + + name = options.benchmark + if options.pure_python: + name += "_pure_python" + + if not options.pure_python: + # C accelerators are enabled by default on 3.x + import pickle + if not is_accelerated_module(pickle): + raise RuntimeError("Missing C accelerators for pickle") + else: + sys.modules['_pickle'] = None + import pickle + if is_accelerated_module(pickle): + raise RuntimeError("Unexpected C accelerators for pickle") + + if options.protocol is None: + options.protocol = pickle.HIGHEST_PROTOCOL + + benchmark(512, pickle, options) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + +if __name__ == "__main__": + run() diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_richards.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_richards.py new file mode 100644 index 0000000000..90b72a3aec --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/bm_richards.py @@ -0,0 +1,434 @@ +""" +based on a Java version: + Based on original version written in BCPL by Dr Martin Richards + in 1981 at Cambridge University Computer Laboratory, England + and a C++ version derived from a Smalltalk version written by + L Peter Deutsch. + Java version: Copyright (C) 1995 Sun Microsystems, Inc. + Translation from C++, Mario Wolczko + Outer loop added by Alex Jacoby +""" + + +# Task IDs +I_IDLE = 1 +I_WORK = 2 +I_HANDLERA = 3 +I_HANDLERB = 4 +I_DEVA = 5 +I_DEVB = 6 + +# Packet types +K_DEV = 1000 +K_WORK = 1001 + +# Packet + +BUFSIZE = 4 + +BUFSIZE_RANGE = range(BUFSIZE) + + +class Packet(object): + + def __init__(self, l, i, k): + self.link = l + self.ident = i + self.kind = k + self.datum = 0 + self.data = [0] * BUFSIZE + + def append_to(self, lst): + self.link = None + if lst is None: + return self + else: + p = lst + next = p.link + while next is not None: + p = next + next = p.link + p.link = self + return lst + +# Task Records + + +class TaskRec(object): + pass + + +class DeviceTaskRec(TaskRec): + + def __init__(self): + self.pending = None + + +class IdleTaskRec(TaskRec): + + def __init__(self): + self.control = 1 + self.count = 10000 + + +class HandlerTaskRec(TaskRec): + + def __init__(self): + self.work_in = None + self.device_in = None + + def workInAdd(self, p): + self.work_in = p.append_to(self.work_in) + return self.work_in + + def deviceInAdd(self, p): + self.device_in = p.append_to(self.device_in) + return self.device_in + + +class WorkerTaskRec(TaskRec): + + def __init__(self): + self.destination = I_HANDLERA + self.count = 0 +# Task + + +class TaskState(object): + + def __init__(self): + self.packet_pending = True + self.task_waiting = False + self.task_holding = False + + def packetPending(self): + self.packet_pending = True + self.task_waiting = False + self.task_holding = False + return self + + def waiting(self): + self.packet_pending = False + self.task_waiting = True + self.task_holding = False + return self + + def running(self): + self.packet_pending = False + self.task_waiting = False + self.task_holding = False + return self + + def waitingWithPacket(self): + self.packet_pending = True + self.task_waiting = True + self.task_holding = False + return self + + def isPacketPending(self): + return self.packet_pending + + def isTaskWaiting(self): + return self.task_waiting + + def isTaskHolding(self): + return self.task_holding + + def isTaskHoldingOrWaiting(self): + return self.task_holding or (not self.packet_pending and self.task_waiting) + + def isWaitingWithPacket(self): + return self.packet_pending and self.task_waiting and not self.task_holding + + +tracing = False +layout = 0 + + +def trace(a): + global layout + layout -= 1 + if layout <= 0: + print() + layout = 50 + print(a, end='') + + +TASKTABSIZE = 10 + + +class TaskWorkArea(object): + + def __init__(self): + self.taskTab = [None] * TASKTABSIZE + + self.taskList = None + + self.holdCount = 0 + self.qpktCount = 0 + + +taskWorkArea = TaskWorkArea() + + +class Task(TaskState): + + def __init__(self, i, p, w, initialState, r): + self.link = taskWorkArea.taskList + self.ident = i + self.priority = p + self.input = w + + self.packet_pending = initialState.isPacketPending() + self.task_waiting = initialState.isTaskWaiting() + self.task_holding = initialState.isTaskHolding() + + self.handle = r + + taskWorkArea.taskList = self + taskWorkArea.taskTab[i] = self + + def fn(self, pkt, r): + raise NotImplementedError + + def addPacket(self, p, old): + if self.input is None: + self.input = p + self.packet_pending = True + if self.priority > old.priority: + return self + else: + p.append_to(self.input) + return old + + def runTask(self): + if self.isWaitingWithPacket(): + msg = self.input + self.input = msg.link + if self.input is None: + self.running() + else: + self.packetPending() + else: + msg = None + + return self.fn(msg, self.handle) + + def waitTask(self): + self.task_waiting = True + return self + + def hold(self): + taskWorkArea.holdCount += 1 + self.task_holding = True + return self.link + + def release(self, i): + t = self.findtcb(i) + t.task_holding = False + if t.priority > self.priority: + return t + else: + return self + + def qpkt(self, pkt): + t = self.findtcb(pkt.ident) + taskWorkArea.qpktCount += 1 + pkt.link = None + pkt.ident = self.ident + return t.addPacket(pkt, self) + + def findtcb(self, id): + t = taskWorkArea.taskTab[id] + if t is None: + raise Exception("Bad task id %d" % id) + return t + + +# DeviceTask + + +class DeviceTask(Task): + + def __init__(self, i, p, w, s, r): + Task.__init__(self, i, p, w, s, r) + + def fn(self, pkt, r): + d = r + assert isinstance(d, DeviceTaskRec) + if pkt is None: + pkt = d.pending + if pkt is None: + return self.waitTask() + else: + d.pending = None + return self.qpkt(pkt) + else: + d.pending = pkt + if tracing: + trace(pkt.datum) + return self.hold() + + +class HandlerTask(Task): + + def __init__(self, i, p, w, s, r): + Task.__init__(self, i, p, w, s, r) + + def fn(self, pkt, r): + h = r + assert isinstance(h, HandlerTaskRec) + if pkt is not None: + if pkt.kind == K_WORK: + h.workInAdd(pkt) + else: + h.deviceInAdd(pkt) + work = h.work_in + if work is None: + return self.waitTask() + count = work.datum + if count >= BUFSIZE: + h.work_in = work.link + return self.qpkt(work) + + dev = h.device_in + if dev is None: + return self.waitTask() + + h.device_in = dev.link + dev.datum = work.data[count] + work.datum = count + 1 + return self.qpkt(dev) + +# IdleTask + + +class IdleTask(Task): + + def __init__(self, i, p, w, s, r): + Task.__init__(self, i, 0, None, s, r) + + def fn(self, pkt, r): + i = r + assert isinstance(i, IdleTaskRec) + i.count -= 1 + if i.count == 0: + return self.hold() + elif i.control & 1 == 0: + i.control //= 2 + return self.release(I_DEVA) + else: + i.control = i.control // 2 ^ 0xd008 + return self.release(I_DEVB) + + +# WorkTask + + +A = ord('A') + + +class WorkTask(Task): + + def __init__(self, i, p, w, s, r): + Task.__init__(self, i, p, w, s, r) + + def fn(self, pkt, r): + w = r + assert isinstance(w, WorkerTaskRec) + if pkt is None: + return self.waitTask() + + if w.destination == I_HANDLERA: + dest = I_HANDLERB + else: + dest = I_HANDLERA + + w.destination = dest + pkt.ident = dest + pkt.datum = 0 + + for i in BUFSIZE_RANGE: # range(BUFSIZE) + w.count += 1 + if w.count > 26: + w.count = 1 + pkt.data[i] = A + w.count - 1 + + return self.qpkt(pkt) + + +def schedule(): + t = taskWorkArea.taskList + while t is not None: + if tracing: + print("tcb =", t.ident) + + if t.isTaskHoldingOrWaiting(): + t = t.link + else: + if tracing: + trace(chr(ord("0") + t.ident)) + t = t.runTask() + + +class Richards(object): + + def run(self, iterations): + for i in range(iterations): + taskWorkArea.holdCount = 0 + taskWorkArea.qpktCount = 0 + + IdleTask(I_IDLE, 1, 10000, TaskState().running(), IdleTaskRec()) + + wkq = Packet(None, 0, K_WORK) + wkq = Packet(wkq, 0, K_WORK) + WorkTask(I_WORK, 1000, wkq, TaskState( + ).waitingWithPacket(), WorkerTaskRec()) + + wkq = Packet(None, I_DEVA, K_DEV) + wkq = Packet(wkq, I_DEVA, K_DEV) + wkq = Packet(wkq, I_DEVA, K_DEV) + HandlerTask(I_HANDLERA, 2000, wkq, TaskState( + ).waitingWithPacket(), HandlerTaskRec()) + + wkq = Packet(None, I_DEVB, K_DEV) + wkq = Packet(wkq, I_DEVB, K_DEV) + wkq = Packet(wkq, I_DEVB, K_DEV) + HandlerTask(I_HANDLERB, 3000, wkq, TaskState( + ).waitingWithPacket(), HandlerTaskRec()) + + wkq = None + DeviceTask(I_DEVA, 4000, wkq, + TaskState().waiting(), DeviceTaskRec()) + DeviceTask(I_DEVB, 5000, wkq, + TaskState().waiting(), DeviceTaskRec()) + + schedule() + + if taskWorkArea.holdCount == 9297 and taskWorkArea.qpktCount == 23246: + pass + else: + return False + + return True + + +def run(): + richard = Richards() + richard.run(1) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/chaos.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/chaos.py new file mode 100644 index 0000000000..008938367b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/chaos.py @@ -0,0 +1,314 @@ +"""create chaosgame-like fractals + +Copyright (C) 2005 Carl Friedrich Bolz +""" + +import math +import random +import argparse + + +DEFAULT_THICKNESS = 0.25 +DEFAULT_WIDTH = 256 +DEFAULT_HEIGHT = 256 +DEFAULT_ITERATIONS = 5000 +DEFAULT_RNG_SEED = 1234 + + +class GVector(object): + + def __init__(self, x=0, y=0, z=0): + self.x = x + self.y = y + self.z = z + + def Mag(self): + return math.sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2) + + def dist(self, other): + return math.sqrt((self.x - other.x) ** 2 + + (self.y - other.y) ** 2 + + (self.z - other.z) ** 2) + + def __add__(self, other): + if not isinstance(other, GVector): + raise ValueError("Can't add GVector to " + str(type(other))) + v = GVector(self.x + other.x, self.y + other.y, self.z + other.z) + return v + + def __sub__(self, other): + return self + other * -1 + + def __mul__(self, other): + v = GVector(self.x * other, self.y * other, self.z * other) + return v + __rmul__ = __mul__ + + def linear_combination(self, other, l1, l2=None): + if l2 is None: + l2 = 1 - l1 + v = GVector(self.x * l1 + other.x * l2, + self.y * l1 + other.y * l2, + self.z * l1 + other.z * l2) + return v + + def __str__(self): + return "<%f, %f, %f>" % (self.x, self.y, self.z) + + def __repr__(self): + return "GVector(%f, %f, %f)" % (self.x, self.y, self.z) + + +class Spline(object): + """Class for representing B-Splines and NURBS of arbitrary degree""" + + def __init__(self, points, degree, knots): + """Creates a Spline. + + points is a list of GVector, degree is the degree of the Spline. + """ + if len(points) > len(knots) - degree + 1: + raise ValueError("too many control points") + elif len(points) < len(knots) - degree + 1: + raise ValueError("not enough control points") + last = knots[0] + for cur in knots[1:]: + if cur < last: + raise ValueError("knots not strictly increasing") + last = cur + self.knots = knots + self.points = points + self.degree = degree + + def GetDomain(self): + """Returns the domain of the B-Spline""" + return (self.knots[self.degree - 1], + self.knots[len(self.knots) - self.degree]) + + def __call__(self, u): + """Calculates a point of the B-Spline using de Boors Algorithm""" + dom = self.GetDomain() + if u < dom[0] or u > dom[1]: + raise ValueError("Function value not in domain") + if u == dom[0]: + return self.points[0] + if u == dom[1]: + return self.points[-1] + I = self.GetIndex(u) + d = [self.points[I - self.degree + 1 + ii] + for ii in range(self.degree + 1)] + U = self.knots + for ik in range(1, self.degree + 1): + for ii in range(I - self.degree + ik + 1, I + 2): + ua = U[ii + self.degree - ik] + ub = U[ii - 1] + co1 = (ua - u) / (ua - ub) + co2 = (u - ub) / (ua - ub) + index = ii - I + self.degree - ik - 1 + d[index] = d[index].linear_combination(d[index + 1], co1, co2) + return d[0] + + def GetIndex(self, u): + dom = self.GetDomain() + for ii in range(self.degree - 1, len(self.knots) - self.degree): + if u >= self.knots[ii] and u < self.knots[ii + 1]: + I = ii + break + else: + I = dom[1] - 1 + return I + + def __len__(self): + return len(self.points) + + def __repr__(self): + return "Spline(%r, %r, %r)" % (self.points, self.degree, self.knots) + + +def write_ppm(im, filename): + magic = 'P6\n' + maxval = 255 + w = len(im) + h = len(im[0]) + + with open(filename, "w", encoding="latin1", newline='') as fp: + fp.write(magic) + fp.write('%i %i\n%i\n' % (w, h, maxval)) + for j in range(h): + for i in range(w): + val = im[i][j] + c = val * 255 + fp.write('%c%c%c' % (c, c, c)) + + +class Chaosgame(object): + + def __init__(self, splines, thickness=0.1): + self.splines = splines + self.thickness = thickness + self.minx = min([p.x for spl in splines for p in spl.points]) + self.miny = min([p.y for spl in splines for p in spl.points]) + self.maxx = max([p.x for spl in splines for p in spl.points]) + self.maxy = max([p.y for spl in splines for p in spl.points]) + self.height = self.maxy - self.miny + self.width = self.maxx - self.minx + self.num_trafos = [] + maxlength = thickness * self.width / self.height + for spl in splines: + length = 0 + curr = spl(0) + for i in range(1, 1000): + last = curr + t = 1 / 999 * i + curr = spl(t) + length += curr.dist(last) + self.num_trafos.append(max(1, int(length / maxlength * 1.5))) + self.num_total = sum(self.num_trafos) + + def get_random_trafo(self): + r = random.randrange(int(self.num_total) + 1) + l = 0 + for i in range(len(self.num_trafos)): + if r >= l and r < l + self.num_trafos[i]: + return i, random.randrange(self.num_trafos[i]) + l += self.num_trafos[i] + return len(self.num_trafos) - 1, random.randrange(self.num_trafos[-1]) + + def transform_point(self, point, trafo=None): + x = (point.x - self.minx) / self.width + y = (point.y - self.miny) / self.height + if trafo is None: + trafo = self.get_random_trafo() + start, end = self.splines[trafo[0]].GetDomain() + length = end - start + seg_length = length / self.num_trafos[trafo[0]] + t = start + seg_length * trafo[1] + seg_length * x + basepoint = self.splines[trafo[0]](t) + if t + 1 / 50000 > end: + neighbour = self.splines[trafo[0]](t - 1 / 50000) + derivative = neighbour - basepoint + else: + neighbour = self.splines[trafo[0]](t + 1 / 50000) + derivative = basepoint - neighbour + if derivative.Mag() != 0: + basepoint.x += derivative.y / derivative.Mag() * (y - 0.5) * \ + self.thickness + basepoint.y += -derivative.x / derivative.Mag() * (y - 0.5) * \ + self.thickness + else: + print("r", end='') + self.truncate(basepoint) + return basepoint + + def truncate(self, point): + if point.x >= self.maxx: + point.x = self.maxx + if point.y >= self.maxy: + point.y = self.maxy + if point.x < self.minx: + point.x = self.minx + if point.y < self.miny: + point.y = self.miny + + def create_image_chaos(self, w, h, iterations, filename, rng_seed): + # Always use the same sequence of random numbers + # to get reproductible benchmark + random.seed(rng_seed) + + im = [[1] * h for i in range(w)] + point = GVector((self.maxx + self.minx) / 2, + (self.maxy + self.miny) / 2, 0) + for _ in range(iterations): + point = self.transform_point(point) + x = (point.x - self.minx) / self.width * w + y = (point.y - self.miny) / self.height * h + x = int(x) + y = int(y) + if x == w: + x -= 1 + if y == h: + y -= 1 + im[x][h - y - 1] = 0 + + if filename: + write_ppm(im, filename) + + +def __benchmark__(args): + splines = [ + Spline([ + GVector(1.597350, 3.304460, 0.000000), + GVector(1.575810, 4.123260, 0.000000), + GVector(1.313210, 5.288350, 0.000000), + GVector(1.618900, 5.329910, 0.000000), + GVector(2.889940, 5.502700, 0.000000), + GVector(2.373060, 4.381830, 0.000000), + GVector(1.662000, 4.360280, 0.000000)], + 3, [0, 0, 0, 1, 1, 1, 2, 2, 2]), + Spline([ + GVector(2.804500, 4.017350, 0.000000), + GVector(2.550500, 3.525230, 0.000000), + GVector(1.979010, 2.620360, 0.000000), + GVector(1.979010, 2.620360, 0.000000)], + 3, [0, 0, 0, 1, 1, 1]), + Spline([ + GVector(2.001670, 4.011320, 0.000000), + GVector(2.335040, 3.312830, 0.000000), + GVector(2.366800, 3.233460, 0.000000), + GVector(2.366800, 3.233460, 0.000000)], + 3, [0, 0, 0, 1, 1, 1]) + ] + + chaos = Chaosgame(splines, args.thickness) + chaos.create_image_chaos(args.width, args.height, args.iterations, args.filename, args.rng_seed) + + +def add_cmdline_args(cmd, args): + cmd.append("--width=%s" % args.width) + cmd.append("--height=%s" % args.height) + cmd.append("--thickness=%s" % args.thickness) + cmd.append("--rng-seed=%s" % args.rng_seed) + if args.filename: + cmd.extend(("--filename", args.filename)) + + +def run(): + cmd = argparse.ArgumentParser(prog="python") + cmd.add_argument("--thickness", + type=float, default=DEFAULT_THICKNESS, + help="Thickness (default: %s)" % DEFAULT_THICKNESS) + cmd.add_argument("--width", + type=int, default=DEFAULT_WIDTH, + help="Image width (default: %s)" % DEFAULT_WIDTH) + cmd.add_argument("--height", + type=int, default=DEFAULT_HEIGHT, + help="Image height (default: %s)" % DEFAULT_HEIGHT) + cmd.add_argument("--iterations", + type=int, default=DEFAULT_ITERATIONS, + help="Number of iterations (default: %s)" + % DEFAULT_ITERATIONS) + cmd.add_argument("--filename", metavar="FILENAME.PPM", + help="Output filename of the PPM picture") + cmd.add_argument("--rng-seed", + type=int, default=DEFAULT_RNG_SEED, + help="Random number generator seed (default: %s)" + % DEFAULT_RNG_SEED) + + args = cmd.parse_args() + __benchmark__(args) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/interpreter.tar.bz2 b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/interpreter.tar.bz2 new file mode 100644 index 0000000000..67bf5a89eb Binary files /dev/null and b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/interpreter.tar.bz2 differ diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/telco-bench.b b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/telco-bench.b new file mode 100644 index 0000000000..2c7085d073 Binary files /dev/null and b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/data/telco-bench.b differ diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/fannkuch.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/fannkuch.py new file mode 100644 index 0000000000..f802721521 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/fannkuch.py @@ -0,0 +1,66 @@ +""" +The Computer Language Benchmarks Game +http://benchmarksgame.alioth.debian.org/ + +Contributed by Sokolov Yura, modified by Tupteq. +""" + + +DEFAULT_ARG = 9 + + +def fannkuch(n): + count = list(range(1, n + 1)) + max_flips = 0 + m = n - 1 + r = n + perm1 = list(range(n)) + perm = list(range(n)) + perm1_ins = perm1.insert + perm1_pop = perm1.pop + + while 1: + while r != 1: + count[r - 1] = r + r -= 1 + + if perm1[0] != 0 and perm1[m] != m: + perm = perm1[:] + flips_count = 0 + k = perm[0] + while k: + perm[:k + 1] = perm[k::-1] + flips_count += 1 + k = perm[0] + + if flips_count > max_flips: + max_flips = flips_count + + while r != n: + perm1_ins(r, perm1_pop(0)) + count[r] -= 1 + if count[r] > 0: + break + r += 1 + else: + return max_flips + + +def run(): + fannkuch(DEFAULT_ARG) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/float.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/float.py new file mode 100644 index 0000000000..3db5c78379 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/float.py @@ -0,0 +1,70 @@ +""" +Artificial, floating point-heavy benchmark originally used by Factor. +""" +from math import sin, cos, sqrt + + +POINTS = 100000 + + +class Point(object): + __slots__ = ('x', 'y', 'z') + + def __init__(self, i): + self.x = x = sin(i) + self.y = cos(i) * 3 + self.z = (x * x) / 2 + + def __repr__(self): + return "" % (self.x, self.y, self.z) + + def normalize(self): + x = self.x + y = self.y + z = self.z + norm = sqrt(x * x + y * y + z * z) + self.x /= norm + self.y /= norm + self.z /= norm + + def maximize(self, other): + self.x = self.x if self.x > other.x else other.x + self.y = self.y if self.y > other.y else other.y + self.z = self.z if self.z > other.z else other.z + return self + + +def maximize(points): + next = points[0] + for p in points[1:]: + next = next.maximize(p) + return next + + +def benchmark(n): + points = [None] * n + for i in range(n): + points[i] = Point(i) + for p in points: + p.normalize() + return maximize(points) + + +def run(): + benchmark(POINTS) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/go.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/go.py new file mode 100644 index 0000000000..cd43765c73 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/go.py @@ -0,0 +1,469 @@ +""" +Go board game +""" +import math +import random + + +SIZE = 9 +GAMES = 200 +KOMI = 7.5 +EMPTY, WHITE, BLACK = 0, 1, 2 +SHOW = {EMPTY: '.', WHITE: 'o', BLACK: 'x'} +PASS = -1 +MAXMOVES = SIZE * SIZE * 3 +TIMESTAMP = 0 +MOVES = 0 + + +def to_pos(x, y): + return y * SIZE + x + + +def to_xy(pos): + y, x = divmod(pos, SIZE) + return x, y + + +class Square: + + def __init__(self, board, pos): + self.board = board + self.pos = pos + self.timestamp = TIMESTAMP + self.removestamp = TIMESTAMP + self.zobrist_strings = [random.randrange(9223372036854775807) + for i in range(3)] + + def set_neighbours(self): + x, y = self.pos % SIZE, self.pos // SIZE + self.neighbours = [] + for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + newx, newy = x + dx, y + dy + if 0 <= newx < SIZE and 0 <= newy < SIZE: + self.neighbours.append(self.board.squares[to_pos(newx, newy)]) + + def move(self, color): + global TIMESTAMP, MOVES + TIMESTAMP += 1 + MOVES += 1 + self.board.zobrist.update(self, color) + self.color = color + self.reference = self + self.ledges = 0 + self.used = True + for neighbour in self.neighbours: + neighcolor = neighbour.color + if neighcolor == EMPTY: + self.ledges += 1 + else: + neighbour_ref = neighbour.find(update=True) + if neighcolor == color: + if neighbour_ref.reference.pos != self.pos: + self.ledges += neighbour_ref.ledges + neighbour_ref.reference = self + self.ledges -= 1 + else: + neighbour_ref.ledges -= 1 + if neighbour_ref.ledges == 0: + neighbour.remove(neighbour_ref) + self.board.zobrist.add() + + def remove(self, reference, update=True): + self.board.zobrist.update(self, EMPTY) + self.removestamp = TIMESTAMP + if update: + self.color = EMPTY + self.board.emptyset.add(self.pos) +# if color == BLACK: +# self.board.black_dead += 1 +# else: +# self.board.white_dead += 1 + for neighbour in self.neighbours: + if neighbour.color != EMPTY and neighbour.removestamp != TIMESTAMP: + neighbour_ref = neighbour.find(update) + if neighbour_ref.pos == reference.pos: + neighbour.remove(reference, update) + else: + if update: + neighbour_ref.ledges += 1 + + def find(self, update=False): + reference = self.reference + if reference.pos != self.pos: + reference = reference.find(update) + if update: + self.reference = reference + return reference + + def __repr__(self): + return repr(to_xy(self.pos)) + + +class EmptySet: + + def __init__(self, board): + self.board = board + self.empties = list(range(SIZE * SIZE)) + self.empty_pos = list(range(SIZE * SIZE)) + + def random_choice(self): + choices = len(self.empties) + while choices: + i = int(random.random() * choices) + pos = self.empties[i] + if self.board.useful(pos): + return pos + choices -= 1 + self.set(i, self.empties[choices]) + self.set(choices, pos) + return PASS + + def add(self, pos): + self.empty_pos[pos] = len(self.empties) + self.empties.append(pos) + + def remove(self, pos): + self.set(self.empty_pos[pos], self.empties[len(self.empties) - 1]) + self.empties.pop() + + def set(self, i, pos): + self.empties[i] = pos + self.empty_pos[pos] = i + + +class ZobristHash: + + def __init__(self, board): + self.board = board + self.hash_set = set() + self.hash = 0 + for square in self.board.squares: + self.hash ^= square.zobrist_strings[EMPTY] + self.hash_set.clear() + self.hash_set.add(self.hash) + + def update(self, square, color): + self.hash ^= square.zobrist_strings[square.color] + self.hash ^= square.zobrist_strings[color] + + def add(self): + self.hash_set.add(self.hash) + + def dupe(self): + return self.hash in self.hash_set + + +class Board: + + def __init__(self): + self.squares = [Square(self, pos) for pos in range(SIZE * SIZE)] + for square in self.squares: + square.set_neighbours() + self.reset() + + def reset(self): + for square in self.squares: + square.color = EMPTY + square.used = False + self.emptyset = EmptySet(self) + self.zobrist = ZobristHash(self) + self.color = BLACK + self.finished = False + self.lastmove = -2 + self.history = [] + self.white_dead = 0 + self.black_dead = 0 + + def move(self, pos): + square = self.squares[pos] + if pos != PASS: + square.move(self.color) + self.emptyset.remove(square.pos) + elif self.lastmove == PASS: + self.finished = True + if self.color == BLACK: + self.color = WHITE + else: + self.color = BLACK + self.lastmove = pos + self.history.append(pos) + + def random_move(self): + return self.emptyset.random_choice() + + def useful_fast(self, square): + if not square.used: + for neighbour in square.neighbours: + if neighbour.color == EMPTY: + return True + return False + + def useful(self, pos): + global TIMESTAMP + TIMESTAMP += 1 + square = self.squares[pos] + if self.useful_fast(square): + return True + old_hash = self.zobrist.hash + self.zobrist.update(square, self.color) + empties = opps = weak_opps = neighs = weak_neighs = 0 + for neighbour in square.neighbours: + neighcolor = neighbour.color + if neighcolor == EMPTY: + empties += 1 + continue + neighbour_ref = neighbour.find() + if neighbour_ref.timestamp != TIMESTAMP: + if neighcolor == self.color: + neighs += 1 + else: + opps += 1 + neighbour_ref.timestamp = TIMESTAMP + neighbour_ref.temp_ledges = neighbour_ref.ledges + neighbour_ref.temp_ledges -= 1 + if neighbour_ref.temp_ledges == 0: + if neighcolor == self.color: + weak_neighs += 1 + else: + weak_opps += 1 + neighbour_ref.remove(neighbour_ref, update=False) + dupe = self.zobrist.dupe() + self.zobrist.hash = old_hash + strong_neighs = neighs - weak_neighs + strong_opps = opps - weak_opps + return not dupe and \ + (empties or weak_opps or (strong_neighs and (strong_opps or weak_neighs))) + + def useful_moves(self): + return [pos for pos in self.emptyset.empties if self.useful(pos)] + + def replay(self, history): + for pos in history: + self.move(pos) + + def score(self, color): + if color == WHITE: + count = KOMI + self.black_dead + else: + count = self.white_dead + for square in self.squares: + squarecolor = square.color + if squarecolor == color: + count += 1 + elif squarecolor == EMPTY: + surround = 0 + for neighbour in square.neighbours: + if neighbour.color == color: + surround += 1 + if surround == len(square.neighbours): + count += 1 + return count + + def check(self): + for square in self.squares: + if square.color == EMPTY: + continue + + members1 = set([square]) + changed = True + while changed: + changed = False + for member in members1.copy(): + for neighbour in member.neighbours: + if neighbour.color == square.color and neighbour not in members1: + changed = True + members1.add(neighbour) + ledges1 = 0 + for member in members1: + for neighbour in member.neighbours: + if neighbour.color == EMPTY: + ledges1 += 1 + + root = square.find() + + # print 'members1', square, root, members1 + # print 'ledges1', square, ledges1 + + members2 = set() + for square2 in self.squares: + if square2.color != EMPTY and square2.find() == root: + members2.add(square2) + + ledges2 = root.ledges + # print 'members2', square, root, members1 + # print 'ledges2', square, ledges2 + + assert members1 == members2 + assert ledges1 == ledges2, ('ledges differ at %r: %d %d' % ( + square, ledges1, ledges2)) + + set(self.emptyset.empties) + + empties2 = set() + for square in self.squares: + if square.color == EMPTY: + empties2.add(square.pos) + + def __repr__(self): + result = [] + for y in range(SIZE): + start = to_pos(0, y) + result.append(''.join( + [SHOW[square.color] + ' ' for square in self.squares[start:start + SIZE]])) + return '\n'.join(result) + + +class UCTNode: + + def __init__(self): + self.bestchild = None + self.pos = -1 + self.wins = 0 + self.losses = 0 + self.pos_child = [None for x in range(SIZE * SIZE)] + self.parent = None + + def play(self, board): + """ uct tree search """ + color = board.color + node = self + path = [node] + while True: + pos = node.select(board) + if pos == PASS: + break + board.move(pos) + child = node.pos_child[pos] + if not child: + child = node.pos_child[pos] = UCTNode() + child.unexplored = board.useful_moves() + child.pos = pos + child.parent = node + path.append(child) + break + path.append(child) + node = child + self.random_playout(board) + self.update_path(board, color, path) + + def select(self, board): + """ select move; unexplored children first, then according to uct value """ + if self.unexplored: + i = random.randrange(len(self.unexplored)) + pos = self.unexplored[i] + self.unexplored[i] = self.unexplored[len(self.unexplored) - 1] + self.unexplored.pop() + return pos + elif self.bestchild: + return self.bestchild.pos + else: + return PASS + + def random_playout(self, board): + """ random play until both players pass """ + for x in range(MAXMOVES): # XXX while not self.finished? + if board.finished: + break + board.move(board.random_move()) + + def update_path(self, board, color, path): + """ update win/loss count along path """ + wins = board.score(BLACK) >= board.score(WHITE) + for node in path: + if color == BLACK: + color = WHITE + else: + color = BLACK + if wins == (color == BLACK): + node.wins += 1 + else: + node.losses += 1 + if node.parent: + node.parent.bestchild = node.parent.best_child() + + def score(self): + winrate = self.wins / float(self.wins + self.losses) + parentvisits = self.parent.wins + self.parent.losses + if not parentvisits: + return winrate + nodevisits = self.wins + self.losses + return winrate + math.sqrt((math.log(parentvisits)) / (5 * nodevisits)) + + def best_child(self): + maxscore = -1 + maxchild = None + for child in self.pos_child: + if child and child.score() > maxscore: + maxchild = child + maxscore = child.score() + return maxchild + + def best_visited(self): + maxvisits = -1 + maxchild = None + for child in self.pos_child: + # if child: + # print to_xy(child.pos), child.wins, child.losses, child.score() + if child and (child.wins + child.losses) > maxvisits: + maxvisits, maxchild = (child.wins + child.losses), child + return maxchild + + +# def user_move(board): +# while True: +# text = input('?').strip() +# if text == 'p': +# return PASS +# if text == 'q': +# raise EOFError +# try: +# x, y = [int(i) for i in text.split()] +# except ValueError: +# continue +# if not (0 <= x < SIZE and 0 <= y < SIZE): +# continue +# pos = to_pos(x, y) +# if board.useful(pos): +# return pos + + +def computer_move(board): + pos = board.random_move() + if pos == PASS: + return PASS + tree = UCTNode() + tree.unexplored = board.useful_moves() + nboard = Board() + for game in range(GAMES): + node = tree + nboard.reset() + nboard.replay(board.history) + node.play(nboard) + return tree.best_visited().pos + + +def versus_cpu(): + random.seed(1) + board = Board() + return computer_move(board) + + +def run(): + versus_cpu() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/hexiom.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/hexiom.py new file mode 100644 index 0000000000..596f0876a3 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/hexiom.py @@ -0,0 +1,673 @@ +""" +Solver of Hexiom board game. + +Benchmark from Laurent Vaucher. + +Source: https://github.com/slowfrog/hexiom : hexiom2.py, level36.txt + +(Main function tweaked by Armin Rigo.) +""" + +import io +import argparse + +# 2016-07-07: CPython 3.6 takes ~25 ms to solve the board level 25 +DEFAULT_LEVEL = 25 + + +################################## +class Dir(object): + + def __init__(self, x, y): + self.x = x + self.y = y + + +DIRS = [Dir(1, 0), + Dir(-1, 0), + Dir(0, 1), + Dir(0, -1), + Dir(1, 1), + Dir(-1, -1)] + +EMPTY = 7 + +################################## + + +class Done(object): + MIN_CHOICE_STRATEGY = 0 + MAX_CHOICE_STRATEGY = 1 + HIGHEST_VALUE_STRATEGY = 2 + FIRST_STRATEGY = 3 + MAX_NEIGHBORS_STRATEGY = 4 + MIN_NEIGHBORS_STRATEGY = 5 + + def __init__(self, count, empty=False): + self.count = count + self.cells = None if empty else [ + [0, 1, 2, 3, 4, 5, 6, EMPTY] for i in range(count)] + + def clone(self): + ret = Done(self.count, True) + ret.cells = [self.cells[i][:] for i in range(self.count)] + return ret + + def __getitem__(self, i): + return self.cells[i] + + def set_done(self, i, v): + self.cells[i] = [v] + + def already_done(self, i): + return len(self.cells[i]) == 1 + + def remove(self, i, v): + if v in self.cells[i]: + self.cells[i].remove(v) + return True + else: + return False + + def remove_all(self, v): + for i in range(self.count): + self.remove(i, v) + + def remove_unfixed(self, v): + changed = False + for i in range(self.count): + if not self.already_done(i): + if self.remove(i, v): + changed = True + return changed + + def filter_tiles(self, tiles): + for v in range(8): + if tiles[v] == 0: + self.remove_all(v) + + def next_cell_min_choice(self): + minlen = 10 + mini = -1 + for i in range(self.count): + if 1 < len(self.cells[i]) < minlen: + minlen = len(self.cells[i]) + mini = i + return mini + + def next_cell_max_choice(self): + maxlen = 1 + maxi = -1 + for i in range(self.count): + if maxlen < len(self.cells[i]): + maxlen = len(self.cells[i]) + maxi = i + return maxi + + def next_cell_highest_value(self): + maxval = -1 + maxi = -1 + for i in range(self.count): + if (not self.already_done(i)): + maxvali = max(k for k in self.cells[i] if k != EMPTY) + if maxval < maxvali: + maxval = maxvali + maxi = i + return maxi + + def next_cell_first(self): + for i in range(self.count): + if (not self.already_done(i)): + return i + return -1 + + def next_cell_max_neighbors(self, pos): + maxn = -1 + maxi = -1 + for i in range(self.count): + if not self.already_done(i): + cells_around = pos.hex.get_by_id(i).links + n = sum(1 if (self.already_done(nid) and (self[nid][0] != EMPTY)) else 0 + for nid in cells_around) + if n > maxn: + maxn = n + maxi = i + return maxi + + def next_cell_min_neighbors(self, pos): + minn = 7 + mini = -1 + for i in range(self.count): + if not self.already_done(i): + cells_around = pos.hex.get_by_id(i).links + n = sum(1 if (self.already_done(nid) and (self[nid][0] != EMPTY)) else 0 + for nid in cells_around) + if n < minn: + minn = n + mini = i + return mini + + def next_cell(self, pos, strategy=HIGHEST_VALUE_STRATEGY): + if strategy == Done.HIGHEST_VALUE_STRATEGY: + return self.next_cell_highest_value() + elif strategy == Done.MIN_CHOICE_STRATEGY: + return self.next_cell_min_choice() + elif strategy == Done.MAX_CHOICE_STRATEGY: + return self.next_cell_max_choice() + elif strategy == Done.FIRST_STRATEGY: + return self.next_cell_first() + elif strategy == Done.MAX_NEIGHBORS_STRATEGY: + return self.next_cell_max_neighbors(pos) + elif strategy == Done.MIN_NEIGHBORS_STRATEGY: + return self.next_cell_min_neighbors(pos) + else: + raise Exception("Wrong strategy: %d" % strategy) + +################################## + + +class Node(object): + + def __init__(self, pos, id, links): + self.pos = pos + self.id = id + self.links = links + +################################## + + +class Hex(object): + + def __init__(self, size): + self.size = size + self.count = 3 * size * (size - 1) + 1 + self.nodes_by_id = self.count * [None] + self.nodes_by_pos = {} + id = 0 + for y in range(size): + for x in range(size + y): + pos = (x, y) + node = Node(pos, id, []) + self.nodes_by_pos[pos] = node + self.nodes_by_id[node.id] = node + id += 1 + for y in range(1, size): + for x in range(y, size * 2 - 1): + ry = size + y - 1 + pos = (x, ry) + node = Node(pos, id, []) + self.nodes_by_pos[pos] = node + self.nodes_by_id[node.id] = node + id += 1 + + def link_nodes(self): + for node in self.nodes_by_id: + (x, y) = node.pos + for dir in DIRS: + nx = x + dir.x + ny = y + dir.y + if self.contains_pos((nx, ny)): + node.links.append(self.nodes_by_pos[(nx, ny)].id) + + def contains_pos(self, pos): + return pos in self.nodes_by_pos + + def get_by_pos(self, pos): + return self.nodes_by_pos[pos] + + def get_by_id(self, id): + return self.nodes_by_id[id] + + +################################## +class Pos(object): + + def __init__(self, hex, tiles, done=None): + self.hex = hex + self.tiles = tiles + self.done = Done(hex.count) if done is None else done + + def clone(self): + return Pos(self.hex, self.tiles, self.done.clone()) + +################################## + + +def constraint_pass(pos, last_move=None): + changed = False + left = pos.tiles[:] + done = pos.done + + # Remove impossible values from free cells + free_cells = (range(done.count) if last_move is None + else pos.hex.get_by_id(last_move).links) + for i in free_cells: + if not done.already_done(i): + vmax = 0 + vmin = 0 + cells_around = pos.hex.get_by_id(i).links + for nid in cells_around: + if done.already_done(nid): + if done[nid][0] != EMPTY: + vmin += 1 + vmax += 1 + else: + vmax += 1 + + for num in range(7): + if (num < vmin) or (num > vmax): + if done.remove(i, num): + changed = True + + # Computes how many of each value is still free + for cell in done.cells: + if len(cell) == 1: + left[cell[0]] -= 1 + + for v in range(8): + # If there is none, remove the possibility from all tiles + if (pos.tiles[v] > 0) and (left[v] == 0): + if done.remove_unfixed(v): + changed = True + else: + possible = sum((1 if v in cell else 0) for cell in done.cells) + # If the number of possible cells for a value is exactly the number of available tiles + # put a tile in each cell + if pos.tiles[v] == possible: + for i in range(done.count): + cell = done.cells[i] + if (not done.already_done(i)) and (v in cell): + done.set_done(i, v) + changed = True + + # Force empty or non-empty around filled cells + filled_cells = (range(done.count) if last_move is None + else [last_move]) + for i in filled_cells: + if done.already_done(i): + num = done[i][0] + empties = 0 + filled = 0 + unknown = [] + cells_around = pos.hex.get_by_id(i).links + for nid in cells_around: + if done.already_done(nid): + if done[nid][0] == EMPTY: + empties += 1 + else: + filled += 1 + else: + unknown.append(nid) + if len(unknown) > 0: + if num == filled: + for u in unknown: + if EMPTY in done[u]: + done.set_done(u, EMPTY) + changed = True + # else: + # raise Exception("Houston, we've got a problem") + elif num == filled + len(unknown): + for u in unknown: + if done.remove(u, EMPTY): + changed = True + + return changed + + +ASCENDING = 1 +DESCENDING = -1 + + +def find_moves(pos, strategy, order): + done = pos.done + cell_id = done.next_cell(pos, strategy) + if cell_id < 0: + return [] + + if order == ASCENDING: + return [(cell_id, v) for v in done[cell_id]] + else: + # Try higher values first and EMPTY last + moves = list(reversed([(cell_id, v) + for v in done[cell_id] if v != EMPTY])) + if EMPTY in done[cell_id]: + moves.append((cell_id, EMPTY)) + return moves + + +def play_move(pos, move): + (cell_id, i) = move + pos.done.set_done(cell_id, i) + + +def print_pos(pos, output): + hex = pos.hex + done = pos.done + size = hex.size + for y in range(size): + print(" " * (size - y - 1), end="", file=output) + for x in range(size + y): + pos2 = (x, y) + id = hex.get_by_pos(pos2).id + if done.already_done(id): + c = str(done[id][0]) if done[id][0] != EMPTY else "." + else: + c = "?" + print("%s " % c, end="", file=output) + print(end="\n", file=output) + for y in range(1, size): + print(" " * y, end="", file=output) + for x in range(y, size * 2 - 1): + ry = size + y - 1 + pos2 = (x, ry) + id = hex.get_by_pos(pos2).id + if done.already_done(id): + c = str(done[id][0]) if done[id][0] != EMPTY else "." + else: + c = "?" + print("%s " % c, end="", file=output) + print(end="\n", file=output) + + +OPEN = 0 +SOLVED = 1 +IMPOSSIBLE = -1 + + +def solved(pos, output, verbose=False): + hex = pos.hex + tiles = pos.tiles[:] + done = pos.done + exact = True + all_done = True + for i in range(hex.count): + if len(done[i]) == 0: + return IMPOSSIBLE + elif done.already_done(i): + num = done[i][0] + tiles[num] -= 1 + if (tiles[num] < 0): + return IMPOSSIBLE + vmax = 0 + vmin = 0 + if num != EMPTY: + cells_around = hex.get_by_id(i).links + for nid in cells_around: + if done.already_done(nid): + if done[nid][0] != EMPTY: + vmin += 1 + vmax += 1 + else: + vmax += 1 + + if (num < vmin) or (num > vmax): + return IMPOSSIBLE + if num != vmin: + exact = False + else: + all_done = False + + if (not all_done) or (not exact): + return OPEN + + print_pos(pos, output) + return SOLVED + + +def solve_step(prev, strategy, order, output, first=False): + if first: + pos = prev.clone() + while constraint_pass(pos): + pass + else: + pos = prev + + moves = find_moves(pos, strategy, order) + if len(moves) == 0: + return solved(pos, output) + else: + for move in moves: + # print("Trying (%d, %d)" % (move[0], move[1])) + ret = OPEN + new_pos = pos.clone() + play_move(new_pos, move) + # print_pos(new_pos) + while constraint_pass(new_pos, move[0]): + pass + cur_status = solved(new_pos, output) + if cur_status != OPEN: + ret = cur_status + else: + ret = solve_step(new_pos, strategy, order, output) + if ret == SOLVED: + return SOLVED + return IMPOSSIBLE + + +def check_valid(pos): + hex = pos.hex + tiles = pos.tiles + # fill missing entries in tiles + tot = 0 + for i in range(8): + if tiles[i] > 0: + tot += tiles[i] + else: + tiles[i] = 0 + # check total + if tot != hex.count: + raise Exception( + "Invalid input. Expected %d tiles, got %d." % (hex.count, tot)) + + +def solve(pos, strategy, order, output): + check_valid(pos) + return solve_step(pos, strategy, order, output, first=True) + + +# TODO Write an 'iterator' to go over all x,y positions + +def read_file(file): + lines = [line.strip("\r\n") for line in file.splitlines()] + size = int(lines[0]) + hex = Hex(size) + linei = 1 + tiles = 8 * [0] + done = Done(hex.count) + for y in range(size): + line = lines[linei][size - y - 1:] + p = 0 + for x in range(size + y): + tile = line[p:p + 2] + p += 2 + if tile[1] == ".": + inctile = EMPTY + else: + inctile = int(tile) + tiles[inctile] += 1 + # Look for locked tiles + if tile[0] == "+": + # print("Adding locked tile: %d at pos %d, %d, id=%d" % + # (inctile, x, y, hex.get_by_pos((x, y)).id)) + done.set_done(hex.get_by_pos((x, y)).id, inctile) + + linei += 1 + for y in range(1, size): + ry = size - 1 + y + line = lines[linei][y:] + p = 0 + for x in range(y, size * 2 - 1): + tile = line[p:p + 2] + p += 2 + if tile[1] == ".": + inctile = EMPTY + else: + inctile = int(tile) + tiles[inctile] += 1 + # Look for locked tiles + if tile[0] == "+": + # print("Adding locked tile: %d at pos %d, %d, id=%d" % + # (inctile, x, ry, hex.get_by_pos((x, ry)).id)) + done.set_done(hex.get_by_pos((x, ry)).id, inctile) + linei += 1 + hex.link_nodes() + done.filter_tiles(tiles) + return Pos(hex, tiles, done) + + +def solve_file(file, strategy, order, output): + pos = read_file(file) + solve(pos, strategy, order, output) + + +LEVELS = {} + +LEVELS[2] = (""" +2 + . 1 + . 1 1 + 1 . +""", """\ + 1 1 +. . . + 1 1 +""") + +LEVELS[10] = (""" +3 + +.+. . + +. 0 . 2 + . 1+2 1 . + 2 . 0+. + .+.+. +""", """\ + . . 1 + . 1 . 2 +0 . 2 2 . + . . . . + 0 . . +""") + +LEVELS[20] = (""" +3 + . 5 4 + . 2+.+1 + . 3+2 3 . + +2+. 5 . + . 3 . +""", """\ + 3 3 2 + 4 5 . 1 +3 5 2 . . + 2 . . . + . . . +""") + +LEVELS[25] = (""" +3 + 4 . . + . . 2 . + 4 3 2 . 4 + 2 2 3 . + 4 2 4 +""", """\ + 3 4 2 + 2 4 4 . +. . . 4 2 + . 2 4 3 + . 2 . +""") + +LEVELS[30] = (""" +4 + 5 5 . . + 3 . 2+2 6 + 3 . 2 . 5 . + . 3 3+4 4 . 3 + 4 5 4 . 5 4 + 5+2 . . 3 + 4 . . . +""", """\ + 3 4 3 . + 4 6 5 2 . + 2 5 5 . . 2 +. . 5 4 . 4 3 + . 3 5 4 5 4 + . 2 . 3 3 + . . . . +""") + +LEVELS[36] = (""" +4 + 2 1 1 2 + 3 3 3 . . + 2 3 3 . 4 . + . 2 . 2 4 3 2 + 2 2 . . . 2 + 4 3 4 . . + 3 2 3 3 +""", """\ + 3 4 3 2 + 3 4 4 . 3 + 2 . . 3 4 3 +2 . 1 . 3 . 2 + 3 3 . 2 . 2 + 3 . 2 . 2 + 2 2 . 1 +""") + + +def __benchmark__(loops, level): + board, solution = LEVELS[level] + order = DESCENDING + strategy = Done.FIRST_STRATEGY + stream = io.StringIO() + + board = board.strip() + expected = solution.rstrip() + + range_it = range(loops) + + for _ in range_it: + stream = io.StringIO() + solve_file(board, strategy, order, stream) + output = stream.getvalue() + stream = None + + output = '\n'.join(line.rstrip() for line in output.splitlines()) + if output != expected: + raise AssertionError("got a wrong answer:\n%s\nexpected: %s" + % (output, expected)) + + +def add_cmdline_args(cmd, args): + cmd.extend(("--level", str(args.level))) + + +def run(): + levels = sorted(LEVELS) + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("--level", type=int, + choices=levels, + default=DEFAULT_LEVEL, + help="Hexiom board level (default: %s)" + % DEFAULT_LEVEL) + + args = parser.parse_args() + __benchmark__(16, args.level) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_dumps.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_dumps.py new file mode 100644 index 0000000000..40c514703e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_dumps.py @@ -0,0 +1,69 @@ +import json +import sys +import argparse + + +EMPTY = ({}, 2000) +SIMPLE_DATA = {'key1': 0, 'key2': True, 'key3': 'value', 'key4': 'foo', + 'key5': 'string'} +SIMPLE = (SIMPLE_DATA, 1000) +NESTED_DATA = {'key1': 0, 'key2': SIMPLE[0], 'key3': 'value', 'key4': SIMPLE[0], + 'key5': SIMPLE[0], 'key': '\u0105\u0107\u017c'} +NESTED = (NESTED_DATA, 1000) +HUGE = ([NESTED[0]] * 1000, 1) + +CASES = ['EMPTY', 'SIMPLE', 'NESTED', 'HUGE'] + + +def bench_json_dumps(data): + for obj, count_it in data: + for _ in count_it: + json.dumps(obj) + + +def add_cmdline_args(cmd, args): + if args.cases: + cmd.extend(("--cases", args.cases)) + + +def run(): + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("--cases", + help="Comma separated list of cases. Available cases: %s. By default, run all cases." + % ', '.join(CASES)) + + args = parser.parse_args() + if args.cases: + cases = [] + for case in args.cases.split(','): + case = case.strip() + if case: + cases.append(case) + if not cases: + print("ERROR: empty list of cases") + sys.exit(1) + else: + cases = CASES + + data = [] + for case in cases: + obj, count = globals()[case] + data.append((obj, range(count))) + + bench_json_dumps(data) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_loads.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_loads.py new file mode 100644 index 0000000000..be37c1e169 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/json_loads.py @@ -0,0 +1,115 @@ + +"""Script for testing the performance of json parsing and serialization. + +This will dump/load several real world-representative objects a few +thousand times. The methodology below was chosen for was chosen to be similar +to real-world scenarios which operate on single objects at a time. +""" + +# Python imports +import json +import random +import sys + + +DICT = { + 'ads_flags': 0, + 'age': 18, + 'bulletin_count': 0, + 'comment_count': 0, + 'country': 'BR', + 'encrypted_id': 'G9urXXAJwjE', + 'favorite_count': 9, + 'first_name': '', + 'flags': 412317970704, + 'friend_count': 0, + 'gender': 'm', + 'gender_for_display': 'Male', + 'id': 302935349, + 'is_custom_profile_icon': 0, + 'last_name': '', + 'locale_preference': 'pt_BR', + 'member': 0, + 'tags': ['a', 'b', 'c', 'd', 'e', 'f', 'g'], + 'profile_foo_id': 827119638, + 'secure_encrypted_id': 'Z_xxx2dYx3t4YAdnmfgyKw', + 'session_number': 2, + 'signup_id': '201-19225-223', + 'status': 'A', + 'theme': 1, + 'time_created': 1225237014, + 'time_updated': 1233134493, + 'unread_message_count': 0, + 'user_group': '0', + 'username': 'collinwinter', + 'play_count': 9, + 'view_count': 7, + 'zip': ''} + +TUPLE = ( + [265867233, 265868503, 265252341, 265243910, 265879514, + 266219766, 266021701, 265843726, 265592821, 265246784, + 265853180, 45526486, 265463699, 265848143, 265863062, + 265392591, 265877490, 265823665, 265828884, 265753032], 60) + + +def mutate_dict(orig_dict, random_source): + new_dict = dict(orig_dict) + for key, value in new_dict.items(): + rand_val = random_source.random() * sys.maxsize + if isinstance(key, (int, bytes, str)): + new_dict[key] = type(key)(rand_val) + return new_dict + + +random_source = random.Random(5) # Fixed seed. +DICT_GROUP = [mutate_dict(DICT, random_source) for _ in range(3)] + + +def bench_json_loads(objs): + for obj in objs: + # 20 loads + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + json.loads(obj) + + +def run(): + json_dict = json.dumps(DICT) + json_tuple = json.dumps(TUPLE) + json_dict_group = json.dumps(DICT_GROUP) + objs = (json_dict, json_tuple, json_dict_group) + bench_json_loads(objs) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/meteor_contest.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/meteor_contest.py new file mode 100644 index 0000000000..ec8be6098b --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/meteor_contest.py @@ -0,0 +1,231 @@ +""" +Meteor Puzzle board: +http://benchmarksgame.alioth.debian.org/u32/meteor-description.html#meteor + +The Computer Language Benchmarks Game +http://benchmarksgame.alioth.debian.org/ + +contributed by Daniel Nanz, 2008-08-21 +""" + +from bisect import bisect + + +SOLVE_ARG = 60 + +WIDTH, HEIGHT = 5, 10 +DIR_NO = 6 +S, E = WIDTH * HEIGHT, 2 +SE = S + (E / 2) +SW = SE - E +W, NW, NE = -E, -SE, -SW + +SOLUTIONS = [ + '00001222012661126155865558633348893448934747977799', + '00001222012771127148774485464855968596835966399333', + '00001222012771127148774485494855998596835966366333', + '00001222012771127148774485994855948596835966366333', + '00001222012771127166773863384653846538445584959999', + '00001222012771127183778834833348555446554666969999', + '00001222012771127183778834833348555446554966699996', + '00001223012331123166423564455647456775887888979999', + '00001555015541144177484726877268222683336689399993', + '00001555015541144177484728677286222863338669399993', + '00001599015591159148594482224827748276837766366333', + '00001777017871184155845558449984669662932629322333', + '00004222042664426774996879687759811598315583153331', + '00004222042774427384773183331866118615586555969999', + '00004223042334423784523785771855718566186611969999', + '00004227042874428774528735833155831566316691169999', + '00004333045534455384175781777812228116286662969999', + '00004333045934459384559185991866118612286727267772', + '00004333047734427384277182221866118615586555969999', + '00004555045514411224172621768277368736683339899998', + '00004555045514411224172721777299998966836688368333', + '00004555045534413334132221177266172677886888969999', + '00004555045534473334739967792617926192661882211888', + '00004555045564466694699992288828811233317273177731', + '00004555045564466694699997773172731233312881122888', + '00004555045564496664999962288828811233317273177731', + '00004555045564496664999967773172731233312881122888', + '00004555045584411884171187722866792679236992369333', + '00004555045584411884191189999832226333267372677766', + '00004555045584411884191189999866222623336727367773', + '13335138551389511895778697869947762446624022240000', + '13777137271333211882888226999946669446554055540000', + '13777137271333211882888229999649666446554055540000', + '27776272768221681166819958195548395443954033340000', + '33322392623926696648994485554855148117871077710000', + '33366366773867284772842228449584195119551099510000', + '33366366953869584955849958447784172117721022210000', + '33366366953869589955849458447784172117721022210000', + '33386388663866989999277712727142211441554055540000', + '33396329963297629766822778117148811448554055540000', + '33399366953869586955846458447784172117721022210000', + '37776372763332622266899998119148811448554055540000', + '39999396683336822268277682748477144114551055510000', + '39999398663338622286277862748477144114551055510000', + '66777627376233362223899998119148811448554055540000', + '69999666945564455584333843887738172117721022210000', + '88811228816629162971629776993743337443554055540000', + '88822118821333213727137776999946669446554055540000', + '88822118821333213727137779999649666446554055540000', + '89999893338663786377286712627142211441554055540000', + '99777974743984439884333685556855162116621022210000', + '99995948554483564835648336837766172117721022210000', + '99996119661366513855133853782547782447824072240000', + '99996911668166581755817758732548732443324032240000', + '99996926668261182221877718757148355443554033340000', + '99996955568551681166812228177248372443774033340000', + '99996955568551681166813338137748372447724022240000', + '99996966645564455584333843887738172117721022210000', + '99996988868877627166277112223143331443554055540000', + '99997988878857765474655446532466132113321032210000'] + + +def rotate(ido, rd={E: NE, NE: NW, NW: W, W: SW, SW: SE, SE: E}): + return [rd[o] for o in ido] + + +def flip(ido, fd={E: E, NE: SE, NW: SW, W: W, SW: NW, SE: NE}): + return [fd[o] for o in ido] + + +def permute(ido, r_ido, rotate=rotate, flip=flip): + ps = [ido] + for r in range(DIR_NO - 1): + ps.append(rotate(ps[-1])) + if ido == r_ido: # C2-symmetry + ps = ps[0:DIR_NO // 2] + for pp in ps[:]: + ps.append(flip(pp)) + return ps + + +def convert(ido): + '''incremental direction offsets -> "coordinate offsets" ''' + out = [0] + for o in ido: + out.append(out[-1] + o) + return list(set(out)) + + +def get_footprints(board, cti, pieces): + fps = [[[] for p in range(len(pieces))] for ci in range(len(board))] + for c in board: + for pi, p in enumerate(pieces): + for pp in p: + fp = frozenset([cti[c + o] for o in pp if (c + o) in cti]) + if len(fp) == 5: + fps[min(fp)][pi].append(fp) + return fps + + +def get_senh(board, cti): + '''-> south-east neighborhood''' + se_nh = [] + nh = [E, SW, SE] + for c in board: + se_nh.append(frozenset([cti[c + o] for o in nh if (c + o) in cti])) + return se_nh + + +def get_puzzle(width, height): + board = [E * x + S * y + (y % 2) + for y in range(height) + for x in range(width)] + cti = dict((board[i], i) for i in range(len(board))) + + # Incremental direction offsets + idos = [[E, E, E, SE], + [SE, SW, W, SW], + [W, W, SW, SE], + [E, E, SW, SE], + [NW, W, NW, SE, SW], + [E, E, NE, W], + [NW, NE, NE, W], + [NE, SE, E, NE], + [SE, SE, E, SE], + [E, NW, NW, NW]] + + # Restrict piece 4 + perms = (permute(p, idos[3]) for p in idos) + pieces = [[convert(pp) for pp in p] for p in perms] + return (board, cti, pieces) + + +def solve(n, i_min, free, curr_board, pieces_left, solutions, fps, se_nh, + # Hack to use a fast local variable to avoid a global lookup + bisect=bisect): + + fp_i_cands = fps[i_min] + for p in pieces_left: + fp_cands = fp_i_cands[p] + for fp in fp_cands: + if fp <= free: + n_curr_board = curr_board[:] + for ci in fp: + n_curr_board[ci] = p + + if len(pieces_left) > 1: + n_free = free - fp + n_i_min = min(n_free) + if len(n_free & se_nh[n_i_min]) > 0: + n_pieces_left = pieces_left[:] + n_pieces_left.remove(p) + solve(n, n_i_min, n_free, n_curr_board, + n_pieces_left, solutions, fps, se_nh) + else: + s = ''.join(map(str, n_curr_board)) + solutions.insert(bisect(solutions, s), s) + rs = s[::-1] + solutions.insert(bisect(solutions, rs), rs) + if len(solutions) >= n: + return + + if len(solutions) >= n: + return + + +def bench_meteor_contest(loops, board, pieces, solve_arg, fps, se_nh): + range_it = range(loops) + + for _ in range_it: + free = frozenset(range(len(board))) + curr_board = [-1] * len(board) + pieces_left = list(range(len(pieces))) + solutions = [] + solve(solve_arg, 0, free, curr_board, pieces_left, + solutions, fps, se_nh) + + if solutions != SOLUTIONS: + raise ValueError("unexpected solutions") + + +def __benchmark__(): + board, cti, pieces = get_puzzle(WIDTH, HEIGHT) + fps = get_footprints(board, cti, pieces) + se_nh = get_senh(board, cti) + + solve_arg = SOLVE_ARG + bench_meteor_contest(1, board, pieces, solve_arg, fps, se_nh) + + +def run(): + __benchmark__() + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nbody.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nbody.py new file mode 100644 index 0000000000..f25816e09d --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nbody.py @@ -0,0 +1,167 @@ +""" +N-body benchmark from the Computer Language Benchmarks Game. + +This is intended to support Unladen Swallow's pyperf.py. Accordingly, it has been +modified from the Shootout version: +- Accept standard Unladen Swallow benchmark options. +- Run report_energy()/advance() in a loop. +- Reimplement itertools.combinations() to work with older Python versions. + +Pulled from: +http://benchmarksgame.alioth.debian.org/u64q/program.php?test=nbody&lang=python3&id=1 + +Contributed by Kevin Carson. +Modified by Tupteq, Fredrik Johansson, and Daniel Nanz. +""" + +import argparse + +__contact__ = "collinwinter@google.com (Collin Winter)" +DEFAULT_ITERATIONS = 20000 +DEFAULT_REFERENCE = 'sun' + + +def combinations(l): + """Pure-Python implementation of itertools.combinations(l, 2).""" + result = [] + for x in range(len(l) - 1): + ls = l[x + 1:] + for y in ls: + result.append((l[x], y)) + return result + + +PI = 3.14159265358979323 +SOLAR_MASS = 4 * PI * PI +DAYS_PER_YEAR = 365.24 + +BODIES = { + 'sun': ([0.0, 0.0, 0.0], [0.0, 0.0, 0.0], SOLAR_MASS), + + 'jupiter': ([4.84143144246472090e+00, + -1.16032004402742839e+00, + -1.03622044471123109e-01], + [1.66007664274403694e-03 * DAYS_PER_YEAR, + 7.69901118419740425e-03 * DAYS_PER_YEAR, + -6.90460016972063023e-05 * DAYS_PER_YEAR], + 9.54791938424326609e-04 * SOLAR_MASS), + + 'saturn': ([8.34336671824457987e+00, + 4.12479856412430479e+00, + -4.03523417114321381e-01], + [-2.76742510726862411e-03 * DAYS_PER_YEAR, + 4.99852801234917238e-03 * DAYS_PER_YEAR, + 2.30417297573763929e-05 * DAYS_PER_YEAR], + 2.85885980666130812e-04 * SOLAR_MASS), + + 'uranus': ([1.28943695621391310e+01, + -1.51111514016986312e+01, + -2.23307578892655734e-01], + [2.96460137564761618e-03 * DAYS_PER_YEAR, + 2.37847173959480950e-03 * DAYS_PER_YEAR, + -2.96589568540237556e-05 * DAYS_PER_YEAR], + 4.36624404335156298e-05 * SOLAR_MASS), + + 'neptune': ([1.53796971148509165e+01, + -2.59193146099879641e+01, + 1.79258772950371181e-01], + [2.68067772490389322e-03 * DAYS_PER_YEAR, + 1.62824170038242295e-03 * DAYS_PER_YEAR, + -9.51592254519715870e-05 * DAYS_PER_YEAR], + 5.15138902046611451e-05 * SOLAR_MASS)} + + +SYSTEM = list(BODIES.values()) +PAIRS = combinations(SYSTEM) + + +def advance(dt, n, bodies=SYSTEM, pairs=PAIRS): + for i in range(n): + for (([x1, y1, z1], v1, m1), + ([x2, y2, z2], v2, m2)) in pairs: + dx = x1 - x2 + dy = y1 - y2 + dz = z1 - z2 + mag = dt * ((dx * dx + dy * dy + dz * dz) ** (-1.5)) + b1m = m1 * mag + b2m = m2 * mag + v1[0] -= dx * b2m + v1[1] -= dy * b2m + v1[2] -= dz * b2m + v2[0] += dx * b1m + v2[1] += dy * b1m + v2[2] += dz * b1m + for (r, [vx, vy, vz], m) in bodies: + r[0] += dt * vx + r[1] += dt * vy + r[2] += dt * vz + + +def report_energy(bodies=SYSTEM, pairs=PAIRS, e=0.0): + for (((x1, y1, z1), v1, m1), + ((x2, y2, z2), v2, m2)) in pairs: + dx = x1 - x2 + dy = y1 - y2 + dz = z1 - z2 + e -= (m1 * m2) / ((dx * dx + dy * dy + dz * dz) ** 0.5) + for (r, [vx, vy, vz], m) in bodies: + e += m * (vx * vx + vy * vy + vz * vz) / 2. + return e + + +def offset_momentum(ref, bodies=SYSTEM, px=0.0, py=0.0, pz=0.0): + for (r, [vx, vy, vz], m) in bodies: + px -= vx * m + py -= vy * m + pz -= vz * m + (r, v, m) = ref + v[0] = px / m + v[1] = py / m + v[2] = pz / m + + +def bench_nbody(loops, reference, iterations): + # Set up global state + offset_momentum(BODIES[reference]) + + range_it = range(loops) + + for _ in range_it: + report_energy() + advance(0.01, iterations) + report_energy() + + +def add_cmdline_args(cmd, args): + cmd.extend(("--iterations", str(args.iterations))) + + +def run(): + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("--iterations", + type=int, default=DEFAULT_ITERATIONS, + help="Number of nbody advance() iterations " + "(default: %s)" % DEFAULT_ITERATIONS) + parser.add_argument("--reference", + type=str, default=DEFAULT_REFERENCE, + help="nbody reference (default: %s)" + % DEFAULT_REFERENCE) + + args = parser.parse_args() + bench_nbody(1, args.reference, args.iterations) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nqueens.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nqueens.py new file mode 100644 index 0000000000..61e3eb6547 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/nqueens.py @@ -0,0 +1,72 @@ +"""Simple, brute-force N-Queens solver.""" + +__author__ = "collinwinter@google.com (Collin Winter)" + + +# Pure-Python implementation of itertools.permutations(). +def permutations(iterable, r=None): + """permutations(range(3), 2) --> (0,1) (0,2) (1,0) (1,2) (2,0) (2,1)""" + pool = tuple(iterable) + n = len(pool) + if r is None: + r = n + indices = list(range(n)) + cycles = list(range(n - r + 1, n + 1))[::-1] + yield tuple(pool[i] for i in indices[:r]) + while n: + for i in reversed(range(r)): + cycles[i] -= 1 + if cycles[i] == 0: + indices[i:] = indices[i + 1:] + indices[i:i + 1] + cycles[i] = n - i + else: + j = cycles[i] + indices[i], indices[-j] = indices[-j], indices[i] + yield tuple(pool[i] for i in indices[:r]) + break + else: + return + + +# From http://code.activestate.com/recipes/576647/ +def n_queens(queen_count): + """N-Queens solver. + + Args: + queen_count: the number of queens to solve for. This is also the + board size. + + Yields: + Solutions to the problem. Each yielded value is looks like + (3, 8, 2, 1, 4, ..., 6) where each number is the column position for the + queen, and the index into the tuple indicates the row. + """ + cols = range(queen_count) + for vec in permutations(cols): + if (queen_count == len(set(vec[i] + i for i in cols)) + == len(set(vec[i] - i for i in cols))): + yield vec + + +def bench_n_queens(queen_count): + list(n_queens(queen_count)) + + +def run(): + bench_n_queens(8) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_dict.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_dict.py new file mode 100644 index 0000000000..b74c4ebfaf --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_dict.py @@ -0,0 +1,28 @@ +import sys +import os +# Add benchmark directory to path to allow import of bm_pickle.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import bm_pickle + +def run(): + bm_pickle.__benchmark__(["pickle_dict"]) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["bm_pickle.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_list.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_list.py new file mode 100644 index 0000000000..f4bd72b3fc --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pickle_list.py @@ -0,0 +1,28 @@ +import sys +import os +# Add benchmark directory to path to allow import of bm_pickle.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import bm_pickle + +def run(): + bm_pickle.__benchmark__(["pickle_list"]) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["bm_pickle.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pidigits.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pidigits.py new file mode 100644 index 0000000000..ecf859d56a --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pidigits.py @@ -0,0 +1,81 @@ +# coding: utf-8 +""" +Calculating some of the digits of π. + +This benchmark stresses big integer arithmetic. + +Adapted from code on: +http://benchmarksgame.alioth.debian.org/ +""" + +import itertools +import argparse + + +DEFAULT_DIGITS = 2000 +icount = itertools.count +islice = itertools.islice + + +def gen_x(): + return map(lambda k: (k, 4 * k + 2, 0, 2 * k + 1), icount(1)) + + +def compose(a, b): + aq, ar, as_, at = a + bq, br, bs, bt = b + return (aq * bq, + aq * br + ar * bt, + as_ * bq + at * bs, + as_ * br + at * bt) + + +def extract(z, j): + q, r, s, t = z + return (q * j + r) // (s * j + t) + + +def gen_pi_digits(): + z = (1, 0, 0, 1) + x = gen_x() + while 1: + y = extract(z, 3) + while y != extract(z, 4): + z = compose(z, next(x)) + y = extract(z, 3) + z = compose((10, -10 * y, 0, 1), z) + yield y + + +def calc_ndigits(n): + return list(islice(gen_pi_digits(), n)) + + +def add_cmdline_args(cmd, args): + cmd.extend(("--digits", str(args.digits))) + + +def run(): + cmd = argparse.ArgumentParser(prog="python") + cmd.add_argument("--digits", type=int, default=DEFAULT_DIGITS, + help="Number of computed pi digits (default: %s)" + % DEFAULT_DIGITS) + + args = cmd.parse_args() + calc_ndigits(args.digits) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pyflate.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pyflate.py new file mode 100755 index 0000000000..2372fae59f --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/pyflate.py @@ -0,0 +1,676 @@ +#!/usr/bin/env python +""" +Copyright 2006--2007-01-21 Paul Sladen +http://www.paul.sladen.org/projects/compression/ + +You may use and distribute this code under any DFSG-compatible +license (eg. BSD, GNU GPLv2). + +Stand-alone pure-Python DEFLATE (gzip) and bzip2 decoder/decompressor. +This is probably most useful for research purposes/index building; there +is certainly some room for improvement in the Huffman bit-matcher. + +With the as-written implementation, there was a known bug in BWT +decoding to do with repeated strings. This has been worked around; +see 'bwt_reverse()'. Correct output is produced in all test cases +but ideally the problem would be found... +""" + +import hashlib +import os +import struct + + +int2byte = struct.Struct(">B").pack + + +class BitfieldBase(object): + + def __init__(self, x): + if isinstance(x, BitfieldBase): + self.f = x.f + self.bits = x.bits + self.bitfield = x.bitfield + self.count = x.bitfield + else: + self.f = x + self.bits = 0 + self.bitfield = 0x0 + self.count = 0 + + def _read(self, n): + s = self.f.read(n) + if not s: + raise "Length Error" + self.count += len(s) + return s + + def needbits(self, n): + while self.bits < n: + self._more() + + def _mask(self, n): + return (1 << n) - 1 + + def toskip(self): + return self.bits & 0x7 + + def align(self): + self.readbits(self.toskip()) + + def dropbits(self, n=8): + while n >= self.bits and n > 7: + n -= self.bits + self.bits = 0 + n -= len(self.f._read(n >> 3)) << 3 + if n: + self.readbits(n) + # No return value + + def dropbytes(self, n=1): + self.dropbits(n << 3) + + def tell(self): + return self.count - ((self.bits + 7) >> 3), 7 - ((self.bits - 1) & 0x7) + + def tellbits(self): + bytes, bits = self.tell() + return (bytes << 3) + bits + + +class Bitfield(BitfieldBase): + + def _more(self): + c = self._read(1) + self.bitfield += ord(c) << self.bits + self.bits += 8 + + def snoopbits(self, n=8): + if n > self.bits: + self.needbits(n) + return self.bitfield & self._mask(n) + + def readbits(self, n=8): + if n > self.bits: + self.needbits(n) + r = self.bitfield & self._mask(n) + self.bits -= n + self.bitfield >>= n + return r + + +class RBitfield(BitfieldBase): + + def _more(self): + c = self._read(1) + self.bitfield <<= 8 + self.bitfield += ord(c) + self.bits += 8 + + def snoopbits(self, n=8): + if n > self.bits: + self.needbits(n) + return (self.bitfield >> (self.bits - n)) & self._mask(n) + + def readbits(self, n=8): + if n > self.bits: + self.needbits(n) + r = (self.bitfield >> (self.bits - n)) & self._mask(n) + self.bits -= n + self.bitfield &= ~(self._mask(n) << self.bits) + return r + + +def printbits(v, n): + o = '' + for i in range(n): + if v & 1: + o = '1' + o + else: + o = '0' + o + v >>= 1 + return o + + +class HuffmanLength(object): + + def __init__(self, code, bits=0): + self.code = code + self.bits = bits + self.symbol = None + self.reverse_symbol = None + + def __repr__(self): + return repr((self.code, self.bits, self.symbol, self.reverse_symbol)) + + @staticmethod + def _sort_func(obj): + return (obj.bits, obj.code) + + +def reverse_bits(v, n): + a = 1 << 0 + b = 1 << (n - 1) + z = 0 + for i in range(n - 1, -1, -2): + z |= (v >> i) & a + z |= (v << i) & b + a <<= 1 + b >>= 1 + return z + + +def reverse_bytes(v, n): + a = 0xff << 0 + b = 0xff << (n - 8) + z = 0 + for i in range(n - 8, -8, -16): + z |= (v >> i) & a + z |= (v << i) & b + a <<= 8 + b >>= 8 + return z + + +class HuffmanTable(object): + + def __init__(self, bootstrap): + l = [] + start, bits = bootstrap[0] + for finish, endbits in bootstrap[1:]: + if bits: + for code in range(start, finish): + l.append(HuffmanLength(code, bits)) + start, bits = finish, endbits + if endbits == -1: + break + l.sort(key=HuffmanLength._sort_func) + self.table = l + + def populate_huffman_symbols(self): + bits, symbol = -1, -1 + for x in self.table: + symbol += 1 + if x.bits != bits: + symbol <<= (x.bits - bits) + bits = x.bits + x.symbol = symbol + x.reverse_symbol = reverse_bits(symbol, bits) + + def tables_by_bits(self): + d = {} + for x in self.table: + try: + d[x.bits].append(x) + except: # noqa + d[x.bits] = [x] + + def min_max_bits(self): + self.min_bits, self.max_bits = 16, -1 + for x in self.table: + if x.bits < self.min_bits: + self.min_bits = x.bits + if x.bits > self.max_bits: + self.max_bits = x.bits + + def _find_symbol(self, bits, symbol, table): + for h in table: + if h.bits == bits and h.reverse_symbol == symbol: + return h.code + return -1 + + def find_next_symbol(self, field, reversed=True): + cached_length = -1 + cached = None + for x in self.table: + if cached_length != x.bits: + cached = field.snoopbits(x.bits) + cached_length = x.bits + if (reversed and x.reverse_symbol == cached) or (not reversed and x.symbol == cached): + field.readbits(x.bits) + return x.code + raise Exception("unfound symbol, even after end of table @%r" + % field.tell()) + + for bits in range(self.min_bits, self.max_bits + 1): + r = self._find_symbol(bits, field.snoopbits(bits), self.table) + if 0 <= r: + field.readbits(bits) + return r + elif bits == self.max_bits: + raise "unfound symbol, even after max_bits" + + +class OrderedHuffmanTable(HuffmanTable): + + def __init__(self, lengths): + l = len(lengths) + z = list(zip(range(l), lengths)) + [(l, -1)] + HuffmanTable.__init__(self, z) + + +def code_length_orders(i): + return (16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, + 13, 2, 14, 1, 15)[i] + + +def distance_base(i): + return (1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, + 12289, 16385, 24577)[i] + + +def length_base(i): + return (3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, + 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258)[i - 257] + + +def extra_distance_bits(n): + if 0 <= n <= 1: + return 0 + elif 2 <= n <= 29: + return (n >> 1) - 1 + else: + raise "illegal distance code" + + +def extra_length_bits(n): + if 257 <= n <= 260 or n == 285: + return 0 + elif 261 <= n <= 284: + return ((n - 257) >> 2) - 1 + else: + raise "illegal length code" + + +def move_to_front(l, c): + l[:] = l[c:c + 1] + l[0:c] + l[c + 1:] + + +def bwt_transform(L): + # Semi-inefficient way to get the character counts + F = bytes(sorted(L)) + base = [] + for i in range(256): + base.append(F.find(int2byte(i))) + + pointers = [-1] * len(L) + for i, symbol in enumerate(L): + pointers[base[symbol]] = i + base[symbol] += 1 + return pointers + + +def bwt_reverse(L, end): + out = [] + if len(L): + T = bwt_transform(L) + + # STRAGENESS WARNING: There was a bug somewhere here in that + # if the output of the BWT resolves to a perfect copy of N + # identical strings (think exact multiples of 255 'X' here), + # then a loop is formed. When decoded, the output string would + # be cut off after the first loop, typically '\0\0\0\0\xfb'. + # The previous loop construct was: + # + # next = T[end] + # while next != end: + # out += L[next] + # next = T[next] + # out += L[next] + # + # For the moment, I've instead replaced it with a check to see + # if there has been enough output generated. I didn't figured + # out where the off-by-one-ism is yet---that actually produced + # the cyclic loop. + + for i in range(len(L)): + end = T[end] + out.append(L[end]) + + return bytes(out) + + +def compute_used(b): + huffman_used_map = b.readbits(16) + map_mask = 1 << 15 + used = [] + while map_mask > 0: + if huffman_used_map & map_mask: + huffman_used_bitmap = b.readbits(16) + bit_mask = 1 << 15 + while bit_mask > 0: + if huffman_used_bitmap & bit_mask: + pass + used += [bool(huffman_used_bitmap & bit_mask)] + bit_mask >>= 1 + else: + used += [False] * 16 + map_mask >>= 1 + return used + + +def compute_selectors_list(b, huffman_groups): + selectors_used = b.readbits(15) + mtf = list(range(huffman_groups)) + selectors_list = [] + for i in range(selectors_used): + # zero-terminated bit runs (0..62) of MTF'ed huffman table + c = 0 + while b.readbits(1): + c += 1 + if c >= huffman_groups: + raise "Bzip2 chosen selector greater than number of groups (max 6)" + if c >= 0: + move_to_front(mtf, c) + selectors_list.append(mtf[0]) + return selectors_list + + +def compute_tables(b, huffman_groups, symbols_in_use): + groups_lengths = [] + for j in range(huffman_groups): + length = b.readbits(5) + lengths = [] + for i in range(symbols_in_use): + if not 0 <= length <= 20: + raise "Bzip2 Huffman length code outside range 0..20" + while b.readbits(1): + length -= (b.readbits(1) * 2) - 1 + lengths += [length] + groups_lengths += [lengths] + + tables = [] + for g in groups_lengths: + codes = OrderedHuffmanTable(g) + codes.populate_huffman_symbols() + codes.min_max_bits() + tables.append(codes) + return tables + + +def decode_huffman_block(b, out): + randomised = b.readbits(1) + if randomised: + raise "Bzip2 randomised support not implemented" + pointer = b.readbits(24) + used = compute_used(b) + + huffman_groups = b.readbits(3) + if not 2 <= huffman_groups <= 6: + raise Exception("Bzip2: Number of Huffman groups not in range 2..6") + + selectors_list = compute_selectors_list(b, huffman_groups) + symbols_in_use = sum(used) + 2 # remember RUN[AB] RLE symbols + tables = compute_tables(b, huffman_groups, symbols_in_use) + + favourites = [int2byte(i) for i, x in enumerate(used) if x] + + selector_pointer = 0 + decoded = 0 + # Main Huffman loop + repeat = repeat_power = 0 + buffer = [] + t = None + while True: + decoded -= 1 + if decoded <= 0: + decoded = 50 # Huffman table re-evaluate/switch length + if selector_pointer <= len(selectors_list): + t = tables[selectors_list[selector_pointer]] + selector_pointer += 1 + + r = t.find_next_symbol(b, False) + if 0 <= r <= 1: + if repeat == 0: + repeat_power = 1 + repeat += repeat_power << r + repeat_power <<= 1 + continue + elif repeat > 0: + # Remember kids: If there is only one repeated + # real symbol, it is encoded with *zero* Huffman + # bits and not output... so buffer[-1] doesn't work. + buffer.append(favourites[0] * repeat) + repeat = 0 + if r == symbols_in_use - 1: + break + else: + o = favourites[r - 1] + move_to_front(favourites, r - 1) + buffer.append(o) + pass + + nt = nearly_there = bwt_reverse(b"".join(buffer), pointer) + i = 0 + # Pointless/irritating run-length encoding step + while i < len(nearly_there): + if i < len(nearly_there) - 4 and nt[i] == nt[i + 1] == nt[i + 2] == nt[i + 3]: + out.append(nearly_there[i:i + 1] * (ord(nearly_there[i + 4:i + 5]) + 4)) + i += 5 + else: + out.append(nearly_there[i:i + 1]) + i += 1 + +# Sixteen bits of magic have been removed by the time we start decoding + + +def bzip2_main(input): + b = RBitfield(input) + + method = b.readbits(8) + if method != ord('h'): + raise Exception( + "Unknown (not type 'h'uffman Bzip2) compression method") + + blocksize = b.readbits(8) + if ord('1') <= blocksize <= ord('9'): + blocksize = blocksize - ord('0') + else: + raise Exception("Unknown (not size '0'-'9') Bzip2 blocksize") + + out = [] + while True: + blocktype = b.readbits(48) + b.readbits(32) # crc + if blocktype == 0x314159265359: # (pi) + decode_huffman_block(b, out) + elif blocktype == 0x177245385090: # sqrt(pi) + b.align() + break + else: + raise Exception("Illegal Bzip2 blocktype") + return b''.join(out) + + +# Sixteen bits of magic have been removed by the time we start decoding +def gzip_main(field): + b = Bitfield(field) + method = b.readbits(8) + if method != 8: + raise Exception("Unknown (not type eight DEFLATE) compression method") + + # Use flags, drop modification time, extra flags and OS creator type. + flags = b.readbits(8) + b.readbits(32) # mtime + b.readbits(8) # extra_flags + b.readbits(8) # os_type + + if flags & 0x04: # structured GZ_FEXTRA miscellaneous data + xlen = b.readbits(16) + b.dropbytes(xlen) + while flags & 0x08: # original GZ_FNAME filename + if not b.readbits(8): + break + while flags & 0x10: # human readable GZ_FCOMMENT + if not b.readbits(8): + break + if flags & 0x02: # header-only GZ_FHCRC checksum + b.readbits(16) + + out = [] + while True: + lastbit = b.readbits(1) + blocktype = b.readbits(2) + + if blocktype == 0: + b.align() + length = b.readbits(16) + if length & b.readbits(16): + raise Exception("stored block lengths do not match each other") + for i in range(length): + out.append(int2byte(b.readbits(8))) + + elif blocktype == 1 or blocktype == 2: # Huffman + main_literals, main_distances = None, None + + if blocktype == 1: # Static Huffman + static_huffman_bootstrap = [ + (0, 8), (144, 9), (256, 7), (280, 8), (288, -1)] + static_huffman_lengths_bootstrap = [(0, 5), (32, -1)] + main_literals = HuffmanTable(static_huffman_bootstrap) + main_distances = HuffmanTable(static_huffman_lengths_bootstrap) + + elif blocktype == 2: # Dynamic Huffman + literals = b.readbits(5) + 257 + distances = b.readbits(5) + 1 + code_lengths_length = b.readbits(4) + 4 + + l = [0] * 19 + for i in range(code_lengths_length): + l[code_length_orders(i)] = b.readbits(3) + + dynamic_codes = OrderedHuffmanTable(l) + dynamic_codes.populate_huffman_symbols() + dynamic_codes.min_max_bits() + + # Decode the code_lengths for both tables at once, + # then split the list later + + code_lengths = [] + n = 0 + while n < (literals + distances): + r = dynamic_codes.find_next_symbol(b) + if 0 <= r <= 15: # literal bitlength for this code + count = 1 + what = r + elif r == 16: # repeat last code + count = 3 + b.readbits(2) + # Is this supposed to default to '0' if in the zeroth + # position? + what = code_lengths[-1] + elif r == 17: # repeat zero + count = 3 + b.readbits(3) + what = 0 + elif r == 18: # repeat zero lots + count = 11 + b.readbits(7) + what = 0 + else: + raise Exception( + "next code length is outside of the range 0 <= r <= 18") + code_lengths += [what] * count + n += count + + main_literals = OrderedHuffmanTable(code_lengths[:literals]) + main_distances = OrderedHuffmanTable(code_lengths[literals:]) + + # Common path for both Static and Dynamic Huffman decode now + + main_literals.populate_huffman_symbols() + main_distances.populate_huffman_symbols() + + main_literals.min_max_bits() + main_distances.min_max_bits() + + literal_count = 0 + while True: + r = main_literals.find_next_symbol(b) + if 0 <= r <= 255: + literal_count += 1 + out.append(int2byte(r)) + elif r == 256: + if literal_count > 0: + literal_count = 0 + break + elif 257 <= r <= 285: # dictionary lookup + if literal_count > 0: + literal_count = 0 + length_extra = b.readbits(extra_length_bits(r)) + length = length_base(r) + length_extra + + r1 = main_distances.find_next_symbol(b) + if 0 <= r1 <= 29: + distance = distance_base( + r1) + b.readbits(extra_distance_bits(r1)) + while length > distance: + out += out[-distance:] + length -= distance + if length == distance: + out += out[-distance:] + else: + out += out[-distance:length - distance] + elif 30 <= r1 <= 31: + raise Exception("illegal unused distance symbol " + "in use @%r" % b.tell()) + elif 286 <= r <= 287: + raise Exception("illegal unused literal/length symbol " + "in use @%r" % b.tell()) + elif blocktype == 3: + raise Exception("illegal unused blocktype in use @%r" % b.tell()) + + if lastbit: + break + + b.align() + b.readbits(32) # crc + b.readbits(32) # final_length + return "".join(out) + + +def bench_pyflake(loops, filename): + input_fp = open(filename, 'rb') + range_it = range(loops) + + for _ in range_it: + input_fp.seek(0) + field = RBitfield(input_fp) + + magic = field.readbits(16) + if magic == 0x1f8b: # GZip + out = gzip_main(field) + elif magic == 0x425a: # BZip2 + out = bzip2_main(field) + else: + raise Exception("Unknown file magic %x, not a gzip/bzip2 file" + % hex(magic)) + + input_fp.close() + + if hashlib.md5(out).hexdigest() != "afa004a630fe072901b1d9628b960974": + raise Exception("MD5 checksum mismatch") + + +def run(): + filename = os.path.join(os.path.dirname(__file__), + "data", "interpreter.tar.bz2") + bench_pyflake(1, filename) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["data/interpreter.tar.bz2"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_compile.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_compile.py new file mode 100644 index 0000000000..fe8f79c628 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_compile.py @@ -0,0 +1,83 @@ + +"""Benchmark how quickly Python's regex implementation can compile regexes. + +We bring in all the regexes used by the other regex benchmarks, capture them by +stubbing out the re module, then compile those regexes repeatedly. We muck with +the re module's caching to force it to recompile every regex we give it. +""" + +# Python imports +import re +import sys +import os + + +def capture_regexes(): + regexes = [] + + real_compile = re.compile + real_search = re.search + real_sub = re.sub + + def capture_compile(regex, flags=0): + regexes.append((regex, flags)) + return real_compile(regex, flags) + + def capture_search(regex, target, flags=0): + regexes.append((regex, flags)) + return real_search(regex, target, flags) + + def capture_sub(regex, *args): + regexes.append((regex, 0)) + return real_sub(regex, *args) + + re.compile = capture_compile + re.search = capture_search + re.sub = capture_sub + try: + sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + import regex_effbot + regex_effbot.bench_regex_effbot(1) + + import regex_v8 + regex_v8.bench_regex_v8(1) + finally: + re.compile = real_compile + re.search = real_search + re.sub = real_sub + return regexes + + +def bench_regex_compile(loops, regexes): + range_it = range(loops) + + for _ in range_it: + for regex, flags in regexes: + re.purge() + # ignore result (compiled regex) + re.compile(regex, flags) + + +def run(): + regexes = capture_regexes() + bench_regex_compile(1, regexes) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["regex_effbot.py", "regex_v8.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_dna.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_dna.py new file mode 100644 index 0000000000..b275c3081d --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_dna.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python +""" +The Computer Language Benchmarks Game +http://benchmarksgame.alioth.debian.org/ + +regex-dna Python 3 #5 program: +contributed by Dominique Wahli +2to3 +modified by Justin Peel + +fasta Python 3 #3 program: +modified by Ian Osgood +modified again by Heinrich Acker +modified by Justin Peel +Modified by Christopher Sean Forgeron +""" + +import bisect +import re +import argparse + + +DEFAULT_INIT_LEN = 100000 +DEFAULT_RNG_SEED = 42 + +ALU = ('GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG' + 'GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA' + 'CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT' + 'ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA' + 'GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG' + 'AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC' + 'AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA') + +IUB = list(zip('acgtBDHKMNRSVWY', [0.27, 0.12, 0.12, 0.27] + [0.02] * 11)) + +HOMOSAPIENS = [ + ('a', 0.3029549426680), + ('c', 0.1979883004921), + ('g', 0.1975473066391), + ('t', 0.3015094502008), +] + + +def make_cumulative(table): + P = [] + C = [] + prob = 0. + for char, p in table: + prob += p + P += [prob] + C += [ord(char)] + return (P, C) + + +def repeat_fasta(src, n, nprint): + width = 60 + + is_trailing_line = False + count_modifier = 0.0 + + len_of_src = len(src) + ss = src + src + src[:n % len_of_src] + # CSF - It's faster to work with a bytearray than a string + s = bytearray(ss, encoding='utf8') + + if n % width: + # We don't end on a 60 char wide line + is_trailing_line = True + count_modifier = 1.0 + + # CSF - Here we are stuck with using an int instead of a float for the loop, + # but testing showed it still to be faster than a for loop + count = 0 + end = (n / float(width)) - count_modifier + while count < end: + i = count * 60 % len_of_src + nprint(s[i:i + 60] + b'\n') + count += 1 + if is_trailing_line: + nprint(s[-(n % width):] + b'\n') + + +def random_fasta(table, n, seed, nprint): + width = 60 + r = range(width) + bb = bisect.bisect + + # If we don't have a multiple of the width, then we will have a trailing + # line, which needs a slightly different approach + is_trailing_line = False + count_modifier = 0.0 + + line = bytearray(width + 1) # Width of 60 + 1 for the \n char + + probs, chars = make_cumulative(table) + + # pRNG Vars + im = 139968.0 + seed = float(seed) + + if n % width: + # We don't end on a 60 char wide line + is_trailing_line = True + count_modifier = 1.0 + + # CSF - Loops with a high iteration count run faster as a while/float loop. + count = 0.0 + end = (n / float(width)) - count_modifier + while count < end: + # CSF - Low iteration count loops may run faster as a for loop. + for i in r: + # CSF - Python is faster for all float math than it is for int, on my + # machine at least. + seed = (seed * 3877.0 + 29573.0) % 139968.0 + # CSF - While real values, not variables are faster for most things, on my + # machine, it's faster to have 'im' already in a var + line[i] = chars[bb(probs, seed / im)] + + line[60] = 10 # End of Line + nprint(line) + count += 1.0 + + if is_trailing_line: + for i in range(n % width): + seed = (seed * 3877.0 + 29573.0) % 139968.0 + line[i] = chars[bb(probs, seed / im)] + + nprint(line[:i + 1] + b"\n") + + return seed + + +def init_benchmarks(n, rng_seed): + result = bytearray() + nprint = result.extend + nprint(b'>ONE Homo sapiens alu\n') + repeat_fasta(ALU, n * 2, nprint=nprint) + + # We need to keep track of the state of 'seed' so we pass it in, and return + # it back so our output can pass the diff test + nprint(b'>TWO IUB ambiguity codes\n') + seed = random_fasta(IUB, n * 3, seed=rng_seed, nprint=nprint) + + nprint(b'>THREE Homo sapiens frequency\n') + random_fasta(HOMOSAPIENS, n * 5, seed, nprint=nprint) + + return bytes(result) + + +VARIANTS = ( + b'agggtaaa|tttaccct', + b'[cgt]gggtaaa|tttaccc[acg]', + b'a[act]ggtaaa|tttacc[agt]t', + b'ag[act]gtaaa|tttac[agt]ct', + b'agg[act]taaa|ttta[agt]cct', + b'aggg[acg]aaa|ttt[cgt]ccct', + b'agggt[cgt]aa|tt[acg]accct', + b'agggta[cgt]a|t[acg]taccct', + b'agggtaa[cgt]|[acg]ttaccct', +) + +SUBST = ( + (b'B', b'(c|g|t)'), (b'D', b'(a|g|t)'), (b'H', b'(a|c|t)'), + (b'K', b'(g|t)'), (b'M', b'(a|c)'), (b'N', b'(a|c|g|t)'), + (b'R', b'(a|g)'), (b'S', b'(c|g)'), (b'V', b'(a|c|g)'), + (b'W', b'(a|t)'), (b'Y', b'(c|t)'), +) + + +def run_benchmarks(seq): + ilen = len(seq) + + seq = re.sub(b'>.*\n|\n', b'', seq) + clen = len(seq) + + results = [] + for f in VARIANTS: + results.append(len(re.findall(f, seq))) + + for f, r in SUBST: + seq = re.sub(f, r, seq) + + return results, ilen, clen, len(seq) + + +def bench_regex_dna(loops, seq, expected_res): + range_it = range(loops) + + for i in range_it: + res = run_benchmarks(seq) + + if (expected_res is not None) and (res != expected_res): + raise Exception("run_benchmarks() error") + + +def add_cmdline_args(cmd, args): + cmd.extend(("--fasta-length", str(args.fasta_length), + "--rng-seed", str(args.rng_seed))) + + +def run(): + cmd = argparse.ArgumentParser(prog="python") + cmd.add_argument("--fasta-length", type=int, default=DEFAULT_INIT_LEN, + help="Length of the fasta sequence " + "(default: %s)" % DEFAULT_INIT_LEN) + cmd.add_argument("--rng-seed", type=int, default=DEFAULT_RNG_SEED, + help="Seed of the random number generator " + "(default: %s)" % DEFAULT_RNG_SEED) + + args = cmd.parse_args() + if args.fasta_length == 100000: + expected_len = 1016745 + expected_res = ([6, 26, 86, 58, 113, 31, 31, 32, 43], + 1016745, 1000000, 1336326) + else: + expected_len = None + expected_res = None + + seq = init_benchmarks(args.fasta_length, args.rng_seed) + if (expected_len is not None) and (len(seq) != expected_len): + raise Exception("init_benchmarks() error") + + bench_regex_dna(1, seq, expected_res) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_effbot.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_effbot.py new file mode 100644 index 0000000000..4fb1b26915 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_effbot.py @@ -0,0 +1,183 @@ + +"""Benchmarks for Python's regex engine. + +These are some of the original benchmarks used to tune Python's regex engine +in 2000 written by Fredrik Lundh. Retreived from +http://mail.python.org/pipermail/python-dev/2000-August/007797.html and +integrated into Unladen Swallow's pyperf.py in 2009 by David Laing. + +These benchmarks are of interest since they helped to guide the original +optimization of the sre engine, and we shouldn't necessarily ignore them just +because they're "old". +""" + +# Python imports +import re +import argparse + +USE_BYTES = False + + +def re_compile(s): + if USE_BYTES: + return re.compile(s.encode('latin1')) + else: + return re.compile(s) + +# These are the regular expressions to be tested. These sync up, +# index-for-index with the list of strings generated by gen_string_table() +# below. + + +def gen_regex_table(): + return [ + re_compile('Python|Perl'), + re_compile('Python|Perl'), + re_compile('(Python|Perl)'), + re_compile('(?:Python|Perl)'), + re_compile('Python'), + re_compile('Python'), + re_compile('.*Python'), + re_compile('.*Python.*'), + re_compile('.*(Python)'), + re_compile('.*(?:Python)'), + re_compile('Python|Perl|Tcl'), + re_compile('Python|Perl|Tcl'), + re_compile('(Python|Perl|Tcl)'), + re_compile('(?:Python|Perl|Tcl)'), + re_compile('(Python)\\1'), + re_compile('(Python)\\1'), + re_compile('([0a-z][a-z0-9]*,)+'), + re_compile('(?:[0a-z][a-z0-9]*,)+'), + re_compile('([a-z][a-z0-9]*,)+'), + re_compile('(?:[a-z][a-z0-9]*,)+'), + re_compile('.*P.*y.*t.*h.*o.*n.*')] + + +def gen_string_table(n): + """Generates the list of strings that will be used in the benchmarks. + + All strings have repeated prefixes and suffices, and n specifies the + number of repetitions. + """ + strings = [] + + def append(s): + if USE_BYTES: + strings.append(s.encode('latin1')) + else: + strings.append(s) + append('-' * n + 'Perl' + '-' * n) + append('P' * n + 'Perl' + 'P' * n) + append('-' * n + 'Perl' + '-' * n) + append('-' * n + 'Perl' + '-' * n) + append('-' * n + 'Python' + '-' * n) + append('P' * n + 'Python' + 'P' * n) + append('-' * n + 'Python' + '-' * n) + append('-' * n + 'Python' + '-' * n) + append('-' * n + 'Python' + '-' * n) + append('-' * n + 'Python' + '-' * n) + append('-' * n + 'Perl' + '-' * n) + append('P' * n + 'Perl' + 'P' * n) + append('-' * n + 'Perl' + '-' * n) + append('-' * n + 'Perl' + '-' * n) + append('-' * n + 'PythonPython' + '-' * n) + append('P' * n + 'PythonPython' + 'P' * n) + append('-' * n + 'a5,b7,c9,' + '-' * n) + append('-' * n + 'a5,b7,c9,' + '-' * n) + append('-' * n + 'a5,b7,c9,' + '-' * n) + append('-' * n + 'a5,b7,c9,' + '-' * n) + append('-' * n + 'Python' + '-' * n) + return strings + + +def init_benchmarks(n_values=None): + """Initialize the strings we'll run the regexes against. + + The strings used in the benchmark are prefixed and suffixed by + strings that are repeated n times. + + The sequence n_values contains the values for n. + If n_values is None the values of n from the original benchmark + are used. + + The generated list of strings is cached in the string_tables + variable, which is indexed by n. + + Returns: + A list of string prefix/suffix lengths. + """ + + if n_values is None: + n_values = (0, 5, 50, 250, 1000, 5000, 10000) + + string_tables = {n: gen_string_table(n) for n in n_values} + regexs = gen_regex_table() + + data = [] + for n in n_values: + for id in range(len(regexs)): + regex = regexs[id] + string = string_tables[n][id] + data.append((regex, string)) + return data + + +def bench_regex_effbot(loops): + if bench_regex_effbot.data is None: + bench_regex_effbot.data = init_benchmarks() + data = bench_regex_effbot.data + + range_it = range(loops) + search = re.search + + for _ in range_it: + # Runs all of the benchmarks for a given value of n. + for regex, string in data: + # search 10 times + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + search(regex, string) + + +# cached data, generated at the first call +bench_regex_effbot.data = None + + +def add_cmdline_args(cmd, args): + if args.force_bytes: + cmd.append("--force_bytes") + + +def run(): + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("-B", "--force_bytes", action="store_true", + help="test bytes regexps") + options = parser.parse_args() + if options.force_bytes: + USE_BYTES = True + + bench_regex_effbot(4) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_v8.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_v8.py new file mode 100644 index 0000000000..74ad1c868e --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/regex_v8.py @@ -0,0 +1,1798 @@ +# Copyright 2009 the V8 project authors. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Automatically generated on 2009-01-30. + +# This benchmark is generated by loading 50 of the most popular pages +# on the web and logging all regexp operations performed. Each +# operation is given a weight that is calculated from an estimate of +# the popularity of the pages where it occurs and the number of times +# it is executed while loading each page. Finally the literal +# letters in the data are encoded using ROT13 in a way that does not +# affect how the regexps match their input. + + +# Ported to Python for Unladen Swallow. The original JS version can be found at +# https://github.com/v8/v8/blob/master/benchmarks/regexp.js, r1243. + +# Python imports +import re + + +# The precompiled regexs that were in vars in the V8 code, split into +# tuples of (regex, flags). +compiled_regex_strings = [ + (r'^ba', ''), + (r'(((\w+):\/\/)([^\/:]*)(:(\d+))?)?([^#?]*)(\?([^#]*))?(#(.*))?', ''), + (r'^\s*|\s*$', 'g'), + (r'\bQBZPbageby_cynprubyqre\b', ''), + (r',', ''), + (r'\bQBZPbageby_cynprubyqre\b', 'g'), + (r'^[\s\xa0]+|[\s\xa0]+$', 'g'), + (r'(\d*)(\D*)', 'g'), + (r'=', ''), + (r'(^|\s)lhv\-h(\s|$)', ''), + (r'\#', 'g'), + (r'\.', 'g'), + (r'\'', 'g'), + (r'\?[\w\W]*(sevraqvq|punaaryvq|tebhcvq)=([^\&\?#]*)', 'i'), + (r'\s+', 'g'), + (r'^\s*(\S*(\s+\S+)*)\s*$', ''), + (r'(-[a-z])', 'i'), + (r'(^|[^\\])\"\\\/Qngr\((-?[0-9]+)\)\\\/\"', 'g'), + (r'^\s+|\s+$', 'g'), + (r'(?:^|\s+)ba(?:\s+|$)', ''), + (r'[+, ]', ''), + (r'ybnqrq|pbzcyrgr', ''), + (r'\bso_zrah\b', ''), + (r'^(?:(?:[^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?', ''), + (r'uggcf?:\/\/([^\/]+\.)?snprobbx\.pbz\/', ''), + (r'"', 'g'), + (r'^([^?#]+)(?:\?([^#]*))?(#.*)?', ''), + (r'-\D', 'g'), + (r'\bnpgvingr\b', ''), + (r'%2R', 'gi'), + (r'%2S', 'gi'), + (r'^(mu-(PA|GJ)|wn|xb)$', ''), + (r'\s?;\s?', ''), + (r'%\w?$', ''), + (r'TNQP=([^;]*)', 'i'), + (r'[<>]', 'g'), + (r'uers|fep|fryrpgrq', ''), + (r'\s*([+>~\s])\s*([a-zA-Z#.*:\[])', 'g'), + (r'^(\w+|\*)$', ''), + (r'\\\\', 'g'), + (r' ', 'g'), + (r'\/\xc4\/t', ''), + (r'\/\xd6\/t', ''), + (r'\/\xdc\/t', ''), + (r'\/\xdf\/t', ''), + (r'\/\xe4\/t', ''), + (r'\/\xf6\/t', ''), + (r'\/\xfc\/t', ''), + (r'\W', 'g'), + (r'uers|fep|fglyr', ''), + (r'(?:^|\s+)fryrpgrq(?:\s+|$)', ''), + (r'\&', 'g'), + (r'\+', 'g'), + (r'\?', 'g'), + (r'\t', 'g'), + (r'(\$\{nqiHey\})|(\$nqiHey\b)', 'g'), + (r'(\$\{cngu\})|(\$cngu\b)', 'g'), + (r'##yv4##', 'gi'), + (r'##yv16##', 'gi'), + (r'##yv19##', 'gi'), + (r'(?:^|\s+)bss(?:\s+|$)', ''), + (r'^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$', ''), + (r'^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$', ''), + (r'\{0\}', 'g'), + (r'\b[a-z]', 'g'), + (r'^uggc:\/\/', ''), + (r'(?:^|\s+)qvfnoyrq(?:\s+|$)', ''), + (r'zrah_byq', 'g'), + (r'^([#.]?)((?:[\w' + '\u0128-\uffff' + r'*_-]|\\.)*)', ''), + (r'\{1\}', 'g'), + (r'\s+', ''), + (r'(\$\{4\})|(\$4\b)', 'g'), + (r'(\$\{5\})|(\$5\b)', 'g'), + (r'\{2\}', 'g'), + (r'[^+>] [^+>]', ''), + (r'\bucpyv\s*=\s*([^;]*)', 'i'), + (r'\bucuvqr\s*=\s*([^;]*)', 'i'), + (r'\bucfie\s*=\s*([^;]*)', 'i'), + (r'\bhfucjrn\s*=\s*([^;]*)', 'i'), + (r'\bmvc\s*=\s*([^;]*)', 'i'), + (r'^((?:[\w' + '\u0128-\uffff' + r'*_-]|\\.)+)(#)((?:[\w' + + '\u0128-\uffff' + r'*_-]|\\.)+)', ''), + (r'^([>+~])\s*(\w*)', 'i'), + (r'^>\s*((?:[\w' + '\u0128-\uffff' + r'*_-]|\\.)+)', ''), + (r'^[\s[]?shapgvba', ''), + (r'v\/g.tvs#(.*)', 'i'), + (r'eaq_zbqobkva', ''), + (r';\s*', ''), + (r'(\$\{inyhr\})|(\$inyhr\b)', 'g'), + (r'(\$\{abj\})|(\$abj\b)', 'g'), + (r'\s+$', ''), + (r'^\s+', ''), + (r'(\\\"|\x00-|\x1f|\x7f-|\x9f|' + + '\u00ad|\u0600-|\u0604|\u070f|\u17b4|\u17b5|\u200c-|\u200f|\u2028-|\u202f|\u2060-|\u206f|\ufeff|\ufff0-|\uffff' + r')', 'g'), + (r'^(:)([\w-]+)\("?\'?(.*?(\(.*?\))?[^(]*?)"?\'?\)', ''), + (r'^([:.#]*)((?:[\w' + '\u0128-\uffff' + r'*_-]|\\.)+)', ''), + (r'^(\[) *@?([\w-]+) *([!*$^~=]*) *(\'?"?)(.*?)\4 *\]', '')] + + +# The V8 javascript engine only does one replacement unless the regexp has +# the 'g' flag. Python's sub has count = 1 to do 1 replacement and count = 0 +# to replace all matches. We set this up here. + +regexs = [] +subcount = [] + +for s in compiled_regex_strings: + if 'g' in s[1]: + subcount.append(0) + else: + subcount.append(1) + + if 'i' in s[1]: + regexs.append(re.compile(s[0], re.IGNORECASE | re.UNICODE)) + else: + regexs.append(re.compile(s[0], re.UNICODE)) + +# The strings that were in vars in the V8 benchmark + +strings = [ + r'Zbmvyyn/5.0 (Jvaqbjf; H; Jvaqbjf AG 5.1; ra-HF) NccyrJroXvg/528.9 (XUGZY, yvxr Trpxb) Puebzr/2.0.157.0 Fnsnev/528.9', + r'Fubpxjnir Synfu 9.0 e115', + r'{"anzr":"","ahzoreSbezng":{"PheeraplQrpvznyQvtvgf":2,"PheeraplQrpvznyFrcnengbe":".","VfErnqBayl":gehr,"PheeraplTebhcFvmrf":[3],"AhzoreTebhcFvmrf":[3],"CrepragTebhcFvmrf":[3],"PheeraplTebhcFrcnengbe":",","PheeraplFlzoby":"\xa4","AnAFlzoby":"AnA","PheeraplArtngvirCnggrea":0,"AhzoreArtngvirCnggrea":1,"CrepragCbfvgvirCnggrea":0,"CrepragArtngvirCnggrea":0,"ArtngvirVasvavglFlzoby":"-Vasvavgl","ArtngvirFvta":"-","AhzoreQrpvznyQvtvgf":2,"AhzoreQrpvznyFrcnengbe":".","AhzoreTebhcFrcnengbe":",","PheeraplCbfvgvirCnggrea":0,"CbfvgvirVasvavglFlzoby":"Vasvavgl","CbfvgvirFvta":"+","CrepragQrpvznyQvtvgf":2,"CrepragQrpvznyFrcnengbe":".","CrepragTebhcFrcnengbe":",","CrepragFlzoby":"%","CreZvyyrFlzoby":"\u2030","AngvirQvtvgf":["0","1","2","3","4","5","6","7","8","9"],"QvtvgFhofgvghgvba":1},"qngrGvzrSbezng":{"NZQrfvtangbe":"NZ","Pnyraqne":{"ZvaFhccbegrqQngrGvzr":"@-62135568000000@","ZnkFhccbegrqQngrGvzr":"@253402300799999@","NytbevguzGlcr":1,"PnyraqneGlcr":1,"Renf":[1],"GjbQvtvgLrneZnk":2029,"VfErnqBayl":gehr},"QngrFrcnengbe":"/","SvefgQnlBsJrrx":0,"PnyraqneJrrxEhyr":0,"ShyyQngrGvzrCnggrea":"qqqq, qq ZZZZ llll UU:zz:ff","YbatQngrCnggrea":"qqqq, qq ZZZZ llll","YbatGvzrCnggrea":"UU:zz:ff","ZbaguQnlCnggrea":"ZZZZ qq","CZQrfvtangbe":"CZ","ESP1123Cnggrea":"qqq, qq ZZZ llll UU\':\'zz\':\'ff \'TZG\'","FubegQngrCnggrea":"ZZ/qq/llll","FubegGvzrCnggrea":"UU:zz","FbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq\'G\'UU\':\'zz\':\'ff","GvzrFrcnengbe":":","HavirefnyFbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq UU\':\'zz\':\'ff\'M\'","LrneZbaguCnggrea":"llll ZZZZ","NooerivngrqQnlAnzrf":["Fha","Zba","Ghr","Jrq","Guh","Sev","Fng"],"FubegrfgQnlAnzrf":["Fh","Zb","Gh","Jr","Gu","Se","Fn"],"QnlAnzrf":["Fhaqnl","Zbaqnl","Ghrfqnl","Jrqarfqnl","Guhefqnl","Sevqnl","Fngheqnl"],"NooerivngrqZbaguAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""],"VfErnqBayl":gehr,"AngvirPnyraqneAnzr":"Tertbevna Pnyraqne","NooerivngrqZbaguTravgvirAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguTravgvirAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""]}}', + r'{"anzr":"ra-HF","ahzoreSbezng":{"PheeraplQrpvznyQvtvgf":2,"PheeraplQrpvznyFrcnengbe":".","VfErnqBayl":snyfr,"PheeraplTebhcFvmrf":[3],"AhzoreTebhcFvmrf":[3],"CrepragTebhcFvmrf":[3],"PheeraplTebhcFrcnengbe":",","PheeraplFlzoby":"$","AnAFlzoby":"AnA","PheeraplArtngvirCnggrea":0,"AhzoreArtngvirCnggrea":1,"CrepragCbfvgvirCnggrea":0,"CrepragArtngvirCnggrea":0,"ArtngvirVasvavglFlzoby":"-Vasvavgl","ArtngvirFvta":"-","AhzoreQrpvznyQvtvgf":2,"AhzoreQrpvznyFrcnengbe":".","AhzoreTebhcFrcnengbe":",","PheeraplCbfvgvirCnggrea":0,"CbfvgvirVasvavglFlzoby":"Vasvavgl","CbfvgvirFvta":"+","CrepragQrpvznyQvtvgf":2,"CrepragQrpvznyFrcnengbe":".","CrepragTebhcFrcnengbe":",","CrepragFlzoby":"%","CreZvyyrFlzoby":"\u2030","AngvirQvtvgf":["0","1","2","3","4","5","6","7","8","9"],"QvtvgFhofgvghgvba":1},"qngrGvzrSbezng":{"NZQrfvtangbe":"NZ","Pnyraqne":{"ZvaFhccbegrqQngrGvzr":"@-62135568000000@","ZnkFhccbegrqQngrGvzr":"@253402300799999@","NytbevguzGlcr":1,"PnyraqneGlcr":1,"Renf":[1],"GjbQvtvgLrneZnk":2029,"VfErnqBayl":snyfr},"QngrFrcnengbe":"/","SvefgQnlBsJrrx":0,"PnyraqneJrrxEhyr":0,"ShyyQngrGvzrCnggrea":"qqqq, ZZZZ qq, llll u:zz:ff gg","YbatQngrCnggrea":"qqqq, ZZZZ qq, llll","YbatGvzrCnggrea":"u:zz:ff gg","ZbaguQnlCnggrea":"ZZZZ qq","CZQrfvtangbe":"CZ","ESP1123Cnggrea":"qqq, qq ZZZ llll UU\':\'zz\':\'ff \'TZG\'","FubegQngrCnggrea":"Z/q/llll","FubegGvzrCnggrea":"u:zz gg","FbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq\'G\'UU\':\'zz\':\'ff","GvzrFrcnengbe":":","HavirefnyFbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq UU\':\'zz\':\'ff\'M\'","LrneZbaguCnggrea":"ZZZZ, llll","NooerivngrqQnlAnzrf":["Fha","Zba","Ghr","Jrq","Guh","Sev","Fng"],"FubegrfgQnlAnzrf":["Fh","Zb","Gh","Jr","Gu","Se","Fn"],"QnlAnzrf":["Fhaqnl","Zbaqnl","Ghrfqnl","Jrqarfqnl","Guhefqnl","Sevqnl","Fngheqnl"],"NooerivngrqZbaguAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""],"VfErnqBayl":snyfr,"AngvirPnyraqneAnzr":"Tertbevna Pnyraqne","NooerivngrqZbaguTravgvirAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguTravgvirAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""]}}', + r'HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'uggc://jjj.snprobbx.pbz/vaqrk.cuc', + r';;jvaqbj.IjPurpxZbhfrCbfvgvbaNQ_VQ=shapgvba(r){vs(!r)ine r=jvaqbj.rirag;ine c=-1;vs(d1)c=d1.EbyybssCnary;ine bo=IjTrgBow("IjCnayNQ_VQ_"+c);vs(bo&&bo.fglyr.ivfvovyvgl=="ivfvoyr"){ine fns=IjFns?8:0;ine pheK=r.pyvragK+IjBOFpe("U")+fns,pheL=r.pyvragL+IjBOFpe("I")+fns;ine y=IjBOEC(NQ_VQ,bo,"Y"),g=IjBOEC(NQ_VQ,bo,"G");ine e=y+d1.Cnaryf[c].Jvqgu,o=g+d1.Cnaryf[c].Urvtug;vs((pheKe)||(pheLo)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(d1&&d1.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(d1)d1.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(d1)d1.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;d1.IjTc=d2(n,c){ine nq=d1;vs(vfAnA(c)){sbe(ine v=0;v0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;d1.IjYvzvg0=d2(n,f){ine nq=d1,vh=f.fcyvg("/");sbe(ine v=0;v0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;d1.IjRVST=d2(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",d1.rvsg);};;d1.IjNavzSHC=d2(n,c){ine nq=d1;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ 0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;d1.IjErfrgGvzrbhg=d2(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;d1.IjErfrgNyyGvzrbhgf=d2(n){sbe(ine c=0;ce)||(pheLo)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(jvaqbj.IjNqNQ_VQ&&jvaqbj.IjNqNQ_VQ.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjTc=shapgvba(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(vfAnA(c)){sbe(ine v=0;v0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;jvaqbj.IjNqNQ_VQ.IjYvzvg0=shapgvba(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0;v0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;jvaqbj.IjNqNQ_VQ.IjRVST=shapgvba(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",jvaqbj.IjNqNQ_VQ.rvsg);};;jvaqbj.IjNqNQ_VQ.IjNavzSHC=shapgvba(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ 0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;jvaqbj.IjNqNQ_VQ.IjErfrgGvzrbhg=shapgvba(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;jvaqbj.IjNqNQ_VQ.IjErfrgNyyGvzrbhgf=shapgvba(n){sbe(ine c=0;ce)||(pheLo)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(jvaqbj.IjNqNQ_VQ&&jvaqbj.IjNqNQ_VQ.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjTc=d2(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(vfAnA(c)){sbe(ine v=0;v0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;jvaqbj.IjNqNQ_VQ.IjYvzvg0=d2(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0;v0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;jvaqbj.IjNqNQ_VQ.IjRVST=d2(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",jvaqbj.IjNqNQ_VQ.rvsg);};;jvaqbj.IjNqNQ_VQ.IjNavzSHC=d2(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ 0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;jvaqbj.IjNqNQ_VQ.IjErfrgGvzrbhg=d2(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;jvaqbj.IjNqNQ_VQ.IjErfrgNyyGvzrbhgf=d2(n){sbe(ine c=0;c##yv4##Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.##yv16##Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##', + r'Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.##yv16##Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##', + r'Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##', + r'Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##', + r'Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl. ##N##Yrnea zber##/N##', + r'Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl. Yrnea zber##/N##', + r'Bar Jvaqbjf Yvir VQ trgf lbh vagb Ubgznvy, Zrffratre, Kobk YVIR \u2014 naq bgure cynprf lbh frr #~#argjbexybtb#~#', + r'${1}://${2}${3}${4}${5}', + r' O=6gnyg0g4znrrn&o=3&f=gc; Q=_lyu=K3bQZGSxnT4lZzD3OS9GNmV3ZGLkAQxRpTyxNmRlZmRmAmNkAQLRqTImqNZjOUEgpTjQnJ5xMKtgoN--; SCF=qy', + r'FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n; ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669321699093060&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_tfwsbrg-aowb_80=4413268q3660', + r'FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n; AFP_zp_tfwsbrg-aowb_80=4413268q3660; __hgzm=144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.2294274870215848400.1231364074.1231364074.1231364074.1; __hgzo=144631658.0.10.1231364074; __hgzp=144631658; ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669321699093060&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231364057761&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231364057761&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Ssevraqf.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1667363813.1231364061&tn_fvq=1231364061&tn_uvq=1917563877&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669321699093060&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669321699093060&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'uggc://cebsvyr.zlfcnpr.pbz/Zbqhyrf/Nccyvpngvbaf/Cntrf/Pnainf.nfck', + r'FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669325184628362&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29; __hgzm=144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.3931862196947939300.1231364380.1231364380.1231364380.1; __hgzo=144631658.0.10.1231364380; __hgzp=144631658; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669325184628362&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_vzntrf_wf&qg=1231364373088&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231364373088&punaary=svz_zlfcnpr_hfre-ivrj-pbzzragf%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Spbzzrag.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1158737789.1231364375&tn_fvq=1231364375&tn_uvq=415520832&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669325184628362&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669325184628362&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'#Zbq-Vasb-Vasb-WninFpevcgUvag', + r',n.svryqOgaPnapry', + r'FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669357391353591&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_kkk-gdzogv_80=4413241q3660', + r'FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7; AFP_zp_kkk-gdzogv_80=4413241q3660; AFP_zp_kkk-aowb_80=4413235p3660; __hgzm=144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.2770915348920628700.1231367708.1231367708.1231367708.1; __hgzo=144631658.0.10.1231367708; __hgzp=144631658; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669357391353591&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231367691141&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231367691141&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Sjjj.zlfcnpr.pbz%2S&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=320757904.1231367694&tn_fvq=1231367694&tn_uvq=1758792003&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55332979829981?[NDO]&aqu=1&g=7%2S0%2S2009%2014%3N38%3N42%203%20480&af=zfacbegny&cntrAnzr=HF%20UCZFSGJ&t=uggc%3N%2S%2Sjjj.zfa.pbz%2S&f=1024k768&p=24&x=L&oj=994&ou=634&uc=A&{2}&[NDR]', + r'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq qbhoyr2 ps', + r'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669357391353591&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669357391353591&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'ne;ng;nh;or;oe;pn;pu;py;pa;qr;qx;rf;sv;se;to;ux;vq;vr;va;vg;wc;xe;zk;zl;ay;ab;am;cu;cy;cg;eh;fr;ft;gu;ge;gj;mn;', + r'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886&GHVQ=1', + r'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886', + r'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886; mvc=m:94043|yn:37.4154|yb:-122.0585|p:HF|ue:1', + r'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886; mvc=m:94043|yn:37.4154|yb:-122.0585|p:HF', + r'uggc://gx2.fgp.f-zfa.pbz/oe/uc/11/ra-hf/pff/v/g.tvs#uggc://gx2.fgo.f-zfa.pbz/v/29/4RQP4969777N048NPS4RRR3PO2S7S.wct', + r'uggc://gx2.fgp.f-zfa.pbz/oe/uc/11/ra-hf/pff/v/g.tvs#uggc://gx2.fgo.f-zfa.pbz/v/OQ/63NP9O94NS5OQP1249Q9S1ROP7NS3.wct', + r'zbmvyyn/5.0 (jvaqbjf; h; jvaqbjf ag 5.1; ra-hf) nccyrjroxvg/528.9 (xugzy, yvxr trpxb) puebzr/2.0.157.0 fnsnev/528.9', + r'1231365729213', + r'74.125.75.3-1057165600.29978900', + r'74.125.75.3-1057165600.29978900.1231365730214', + r'Frnepu%20Zvpebfbsg.pbz', + r'FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn; ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669340386893867&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn; __hgzm=144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1877536177953918500.1231365779.1231365779.1231365779.1; __hgzo=144631658.0.10.1231365779; __hgzp=144631658; ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669340386893867&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'I=3%26THVQ=757q3ss871q44o7o805n8113n5p72q52', + r'I=3&THVQ=757q3ss871q44o7o805n8113n5p72q52', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231365765292&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231365765292&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Sohyyrgvaf.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1579793869.1231365768&tn_fvq=1231365768&tn_uvq=2056210897&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'frnepu.zvpebfbsg.pbz', + r'frnepu.zvpebfbsg.pbz/', + r'ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669340386893867&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669340386893867&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'#fubhgobk .pybfr', + r'FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669341278771470&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_dfctwzssrwh-aowb_80=441326q33660', + r'FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98; AFP_zp_dfctwzssrwh-aowb_80=441326q33660; __hgzm=144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1670816052019209000.1231365869.1231365869.1231365869.1; __hgzo=144631658.0.10.1231365869; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669341278771470&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669350559478880&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_dfctwzs-aowb_80=441327q73660', + r'FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473; AFP_zp_dfctwzs-aowb_80=441327q73660; __hgzm=144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1796080716621419500.1231367054.1231367054.1231367054.1; __hgzo=144631658.0.10.1231367054; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669350559478880&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'[glcr=fhozvg]', + r'n.svryqOga,n.svryqOgaPnapry', + r'n.svryqOgaPnapry', + r'oyvpxchaxg', + r'qvi.bow-nppbeqvba qg', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_nccf_wf&qg=1231367052227&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231367052227&punaary=svz_zlfcnpr_nccf-pnainf%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Scebsvyr.zlfcnpr.pbz%2SZbqhyrf%2SNccyvpngvbaf%2SCntrf%2SPnainf.nfck&nq_glcr=grkg&rvq=6083027&rn=0&sez=1&tn_ivq=716357910.1231367056&tn_fvq=1231367056&tn_uvq=1387206491&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231365851658&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231365851658&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Scebsvyrrqvg.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1979828129.1231365855&tn_fvq=1231365855&tn_uvq=2085229649&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22', + r'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55023338617756?[NDO]&aqu=1&g=7%2S0%2S2009%2014%3N12%3N47%203%20480&af=zfacbegny&cntrAnzr=HF%20UCZFSGJ&t=uggc%3N%2S%2Sjjj.zfa.pbz%2S&f=0k0&p=43835816&x=A&oj=994&ou=634&uc=A&{2}&[NDR]', + r'zrgn[anzr=nwnkHey]', + r'anpuevpugra', + r'b oS={\'oT\':1.1};x $8n(B){z(B!=o9)};x $S(B){O(!$8n(B))z A;O(B.4L)z\'T\';b S=7t B;O(S==\'2P\'&&B.p4){23(B.7f){12 1:z\'T\';12 3:z/\S/.2g(B.8M)?\'ox\':\'oh\'}}O(S==\'2P\'||S==\'x\'){23(B.nE){12 2V:z\'1O\';12 7I:z\'5a\';12 18:z\'4B\'}O(7t B.I==\'4F\'){O(B.3u)z\'pG\';O(B.8e)z\'1p\'}}z S};x $2p(){b 4E={};Z(b v=0;v<1p.I;v++){Z(b X 1o 1p[v]){b nc=1p[v][X];b 6E=4E[X];O(6E&&$S(nc)==\'2P\'&&$S(6E)==\'2P\')4E[X]=$2p(6E,nc);17 4E[X]=nc}}z 4E};b $E=7p.E=x(){b 1d=1p;O(!1d[1])1d=[p,1d[0]];Z(b X 1o 1d[1])1d[0][X]=1d[1][X];z 1d[0]};b $4D=7p.pJ=x(){Z(b v=0,y=1p.I;v-1:p.3F(2R)>-1},nX:x(){z p.3y(/([.*+?^${}()|[\]\/\\])/t,\'\\$1\')}});2V.E({5V:x(1O){O(p.I<3)z A;O(p.I==4&&p[3]==0&&!1O)z\'p5\';b 3P=[];Z(b v=0;v<3;v++){b 52=(p[v]-0).4h(16);3P.1x((52.I==1)?\'0\'+52:52)}z 1O?3P:\'#\'+3P.2u(\'\')},5U:x(1O){O(p.I!=3)z A;b 1i=[];Z(b v=0;v<3;v++){1i.1x(5K((p[v].I==1)?p[v]+p[v]:p[v],16))}z 1O?1i:\'1i(\'+1i.2u(\',\')+\')\'}});7F.E({3n:x(P){b J=p;P=$2p({\'L\':J,\'V\':A,\'1p\':1S,\'2x\':A,\'4s\':A,\'6W\':A},P);O($2O(P.1p)&&$S(P.1p)!=\'1O\')P.1p=[P.1p];z x(V){b 1d;O(P.V){V=V||H.V;1d=[(P.V===1r)?V:Y P.V(V)];O(P.1p)1d.E(P.1p)}17 1d=P.1p||1p;b 3C=x(){z J.3H($5S(P', + r'hagreunyghat', + r'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669341278771470&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669350559478880&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q', + r'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669341278771470&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669350559478880&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=', + r'shapgvba (){Cuk.Nccyvpngvba.Frghc.Pber();Cuk.Nccyvpngvba.Frghc.Nwnk();Cuk.Nccyvpngvba.Frghc.Synfu();Cuk.Nccyvpngvba.Frghc.Zbqhyrf()}'] + +# The 12 benchmarking blocks + + +def block0(): + for i in range(6511): + regexs[0].search(r'pyvpx') + + for i in range(1844): + regexs[1].search(r'uggc://jjj.snprobbx.pbz/ybtva.cuc') + + for i in range(739): + regexs[2].sub(r'', 'QBZPbageby_cynprubyqre', subcount[2]) + + for i in range(598): + regexs[1].search(r'uggc://jjj.snprobbx.pbz/') + + for i in range(454): + regexs[1].search(r'uggc://jjj.snprobbx.pbz/fepu.cuc') + + for i in range(352): + re.search( + r'qqqq|qqq|qq|q|ZZZZ|ZZZ|ZZ|Z|llll|ll|l|uu|u|UU|U|zz|z|ff|f|gg|g|sss|ss|s|mmm|mm|m', 'qqqq, ZZZ q, llll') + + for i in range(312): + regexs[3].search(r'vachggrkg QBZPbageby_cynprubyqre') + + for i in range(282): + regexs[4].search(r'/ZlFcnprUbzrcntr/Vaqrk-FvgrUbzr,10000000') + + for i in range(177): + regexs[5].sub(r'', 'vachggrkg', subcount[5]) + + for i in range(170): + regexs[6].sub(r'', '528.9', subcount[6]) + regexs[7].search(r'528') + + for i in range(156): + regexs[8].search(r'VCPhygher=ra-HF') + regexs[8].search(r'CersreerqPhygher=ra-HF') + + for i in range(144): + regexs[0].search(r'xrlcerff') + + for i in range(139): + regexs[6].sub(r'', '521', subcount[6]) + + # This has a different output to the V8 version. + # It could just be a difference in the engines. + regexs[7].search(r'521') + regexs[9].search(r'') + re.search(r'JroXvg\/(\S+)', strings[0]) + + for i in range(137): + regexs[10].sub(r'', 'qvi .so_zrah', subcount[10]) + re.sub(r'\[', '', 'qvi .so_zrah', 0) + regexs[11].sub(r'', 'qvi.so_zrah', subcount[11]) + + for i in range(117): + regexs[2].sub(r'', 'uvqqra_ryrz', subcount[2]) + + for i in range(95): + re.search(r'(?:^|;)\s*sevraqfgre_ynat=([^;]*)', + 'sevraqfgre_naba=nvq%3Qn6ss9p85n868ro9s059pn854735956o3%26ers%3Q%26df%3Q%26vpgl%3QHF') + + for i in range(93): + regexs[12].sub(r'', 'uggc://ubzr.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[13].search(r'uggc://ubzr.zlfcnpr.pbz/vaqrk.psz') + + for i in range(92): + re.sub(r'([a-zA-Z]|\s)+', '', strings[1], 1) + + for i in range(85): + regexs[14].sub(r'', 'svefg', subcount[14]) + regexs[15].sub(r'', 'svefg', subcount[15]) + regexs[12].sub( + r'', 'uggc://cebsvyr.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[14].sub(r'', 'ynfg', subcount[14]) + regexs[15].sub(r'', 'ynfg', subcount[15]) + regexs[16].search(r'qvfcynl') + regexs[13].search(r'uggc://cebsvyr.zlfcnpr.pbz/vaqrk.psz') + + +def block1(): + for i in range(81): + regexs[8].search(r'VC=74.125.75.1') + + for i in range(78): + re.sub(r'(\s)+e', '', '9.0 e115', 1) + re.sub(r'.', '', 'k', 1) + + # This prints a unicode escape where the V8 version prints the + # unicode character. + regexs[17].sub(r'', strings[2], subcount[17]) + + # This prints a unicode escape where the V8 version prints the + # unicode character. + regexs[17].sub(r'', strings[3], subcount[17]) + + regexs[8].search(r'144631658') + regexs[8].search(r'Pbhagel=IIZ%3Q') + regexs[8].search(r'Pbhagel=IIZ=') + regexs[8].search(r'CersreerqPhygherCraqvat=') + regexs[8].search(strings[4]) + regexs[8].search(strings[5]) + regexs[8].search(r'__hgzp=144631658') + regexs[8].search(r'gvzrMbar=-8') + regexs[8].search(r'gvzrMbar=0') + re.search(r'Fnsnev\/(\d+\.\d+)', strings[0]) + regexs[3].search(r'vachggrkg QBZPbageby_cynprubyqre') + regexs[0].search(r'xrlqbja') + regexs[0].search(r'xrlhc') + + for i in range(77): + regexs[12].sub( + r'', 'uggc://zrffntvat.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[13].search(r'uggc://zrffntvat.zlfcnpr.pbz/vaqrk.psz') + + for i in range(73): + regexs[18].sub( + r'', 'FrffvbaFgbentr=%7O%22GnoThvq%22%3N%7O%22thvq%22%3N1231367125017%7Q%7Q', subcount[18]) + + for i in range(72): + regexs[1].search(strings[6]) + + for i in range(71): + regexs[19].search(r'') + + for i in range(70): + regexs[11].sub(r'', '3.5.0.0', subcount[11]) + re.sub(r'd1', '', strings[7], 0) + re.sub(r'NQ_VQ', '', strings[8], 0) + re.sub(r'd2', '', strings[9], 0) + re.sub( + r'_', '', 'NI%3Q1_CI%3Q1_PI%3Q1_EI%3Q1_HI%3Q1_HP%3Q1_IC%3Q0.0.0.0_IH%3Q0', 0) + regexs[20].split( + r'svz_zlfcnpr_ubzrcntr_abgybttrqva,svz_zlfcnpr_aba_HTP,svz_zlfcnpr_havgrq-fgngrf') + regexs[21].search(r'ybnqvat') + + for i in range(68): + regexs[1].search(r'#') + re.search( + r'(?:ZFVR.(\d+\.\d+))|(?:(?:Sversbk|TenaCnenqvfb|Vprjrnfry).(\d+\.\d+))|(?:Bcren.(\d+\.\d+))|(?:NccyrJroXvg.(\d+(?:\.\d+)?))', strings[0]) + re.search(r'(Znp BF K)|(Jvaqbjf;)', strings[0]) + re.search(r'Trpxb\/([0-9]+)', strings[0]) + regexs[21].search(r'ybnqrq') + + for i in range(49): + regexs[16].search(r'pbybe') + + for i in range(44): + regexs[12].sub( + r'', 'uggc://sevraqf.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[13].search(r'uggc://sevraqf.zlfcnpr.pbz/vaqrk.psz') + + +def block2(): + for i in range(40): + regexs[14].sub(r'', 'fryrpgrq', subcount[14]) + regexs[15].sub(r'', 'fryrpgrq', subcount[15]) + + for i in range(39): + re.sub(r'\buvqqra_ryrz\b', '', 'vachggrkg uvqqra_ryrz', 0) + regexs[3].search(r'vachggrkg ') + regexs[3].search(r'vachggrkg') + regexs[22].search(r'HVYvaxOhggba') + regexs[22].search(r'HVYvaxOhggba_E') + regexs[22].search(r'HVYvaxOhggba_EJ') + regexs[22].search(r'zrah_ybtva_pbagnvare') + re.search(r'\buvqqra_ryrz\b', 'vachgcnffjbeq') + + for i in range(37): + regexs[8].search(r'111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904') + regexs[8].search(r'SbeprqRkcvengvba=633669315660164980') + regexs[8].search( + r'FrffvbaQQS2=111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904') + + for i in range(35): + regexs[14].sub(r'', 'puvyq p1 svefg', subcount[14]) + regexs[15].sub(r'', 'puvyq p1 svefg', subcount[15]) + regexs[14].sub(r'', 'sylbhg pybfrq', subcount[14]) + regexs[15].sub(r'', 'sylbhg pybfrq', subcount[15]) + + for i in range(34): + regexs[19].search(r'gno2') + regexs[19].search(r'gno3') + regexs[8].search(r'44132r503660') + regexs[8].search(r'SbeprqRkcvengvba=633669316860113296') + regexs[8].search(r'AFP_zp_dfctwzs-aowb_80=44132r503660') + regexs[8].search( + r'FrffvbaQQS2=s6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696') + regexs[8].search(r's6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696') + + for i in range(32): + re.search(r'puebzr', strings[0], re.IGNORECASE) + + for i in range(31): + regexs[23].sub(r'', 'uggc://jjj.snprobbx.pbz/', subcount[23]) + regexs[8].search(r'SbeprqRkcvengvba=633669358527244818') + regexs[8].search(r'VC=66.249.85.130') + regexs[8].search( + r'FrffvbaQQS2=s15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58') + regexs[8].search(r's15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58') + regexs[24].search(r'uggc://jjj.snprobbx.pbz/') + + for i in range(30): + regexs[6].sub(r'', '419', subcount[6]) + re.search(r'(?:^|\s+)gvzrfgnzc(?:\s+|$)', 'gvzrfgnzc') + regexs[7].search(r'419') + + for i in range(29): + regexs[23].sub(r'', 'uggc://jjj.snprobbx.pbz/ybtva.cuc', subcount[23]) + + for i in range(28): + regexs[25].sub(r'', 'Funer guvf tnqtrg', subcount[25]) + regexs[12].sub(r'', 'Funer guvf tnqtrg', subcount[12]) + regexs[26].search(r'uggc://jjj.tbbtyr.pbz/vt/qverpgbel') + + +def block3(): + for i in range(27): + re.sub(r'[A-Za-z]', '', 'e115', 0) + + for i in range(23): + regexs[27].sub(r'', 'qvfcynl', subcount[27]) + regexs[27].sub(r'', 'cbfvgvba', subcount[27]) + + for i in range(22): + regexs[14].sub(r'', 'unaqyr', subcount[14]) + regexs[15].sub(r'', 'unaqyr', subcount[15]) + regexs[14].sub(r'', 'yvar', subcount[14]) + regexs[15].sub(r'', 'yvar', subcount[15]) + regexs[14].sub(r'', 'cnerag puebzr6 fvatyr1 gno', subcount[14]) + regexs[15].sub(r'', 'cnerag puebzr6 fvatyr1 gno', subcount[15]) + regexs[14].sub(r'', 'fyvqre', subcount[14]) + regexs[15].sub(r'', 'fyvqre', subcount[15]) + regexs[28].search(r'') + + for i in range(21): + regexs[12].sub(r'', 'uggc://jjj.zlfcnpr.pbz/', subcount[12]) + regexs[13].search(r'uggc://jjj.zlfcnpr.pbz/') + + for i in range(20): + regexs[29].sub(r'', 'cntrivrj', subcount[29]) + regexs[30].sub(r'', 'cntrivrj', subcount[30]) + regexs[19].search(r'ynfg') + regexs[19].search(r'ba svefg') + regexs[8].search(r'VC=74.125.75.3') + + for i in range(19): + regexs[31].search(r'ra') + + for i in range(18): + regexs[32].split(strings[10]) + regexs[32].split(strings[11]) + regexs[33].sub(r'', strings[12], subcount[33]) + regexs[8].search(r'144631658.0.10.1231363570') + regexs[8].search( + r'144631658.1231363570.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.3426875219718084000.1231363570.1231363570.1231363570.1') + regexs[8].search(strings[13]) + regexs[8].search(strings[14]) + regexs[8].search( + r'__hgzn=144631658.3426875219718084000.1231363570.1231363570.1231363570.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231363570') + regexs[8].search( + r'__hgzm=144631658.1231363570.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[10]) + regexs[34].search(strings[11]) + + for i in range(17): + re.match(r'zfvr', strings[0], re.IGNORECASE) + re.match(r'bcren', strings[0], re.IGNORECASE) + regexs[32].split(strings[15]) + regexs[32].split(strings[16]) + regexs[14].sub(r'', 'ohggba', subcount[14]) + regexs[15].sub(r'', 'ohggba', subcount[15]) + regexs[14].sub(r'', 'puvyq p1 svefg sylbhg pybfrq', subcount[14]) + regexs[15].sub(r'', 'puvyq p1 svefg sylbhg pybfrq', subcount[15]) + regexs[14].sub(r'', 'pvgvrf', subcount[14]) + regexs[15].sub(r'', 'pvgvrf', subcount[15]) + regexs[14].sub(r'', 'pybfrq', subcount[14]) + regexs[15].sub(r'', 'pybfrq', subcount[15]) + regexs[14].sub(r'', 'qry', subcount[14]) + regexs[15].sub(r'', 'qry', subcount[15]) + regexs[14].sub(r'', 'uqy_zba', subcount[14]) + regexs[15].sub(r'', 'uqy_zba', subcount[15]) + regexs[33].sub(r'', strings[17], subcount[33]) + re.sub(r'%3P', '', strings[18], 0) + re.sub(r'%3R', '', strings[18], 0) + re.sub(r'%3q', '', strings[18], 0) + regexs[35].sub(r'', strings[18], subcount[35]) + regexs[14].sub(r'', 'yvaxyvfg16', subcount[14]) + regexs[15].sub(r'', 'yvaxyvfg16', subcount[15]) + regexs[14].sub(r'', 'zvahf', subcount[14]) + regexs[15].sub(r'', 'zvahf', subcount[15]) + regexs[14].sub(r'', 'bcra', subcount[14]) + regexs[15].sub(r'', 'bcra', subcount[15]) + regexs[14].sub(r'', 'cnerag puebzr5 fvatyr1 ps NU', subcount[14]) + regexs[15].sub(r'', 'cnerag puebzr5 fvatyr1 ps NU', subcount[15]) + regexs[14].sub(r'', 'cynlre', subcount[14]) + regexs[15].sub(r'', 'cynlre', subcount[15]) + regexs[14].sub(r'', 'cyhf', subcount[14]) + regexs[15].sub(r'', 'cyhf', subcount[15]) + regexs[14].sub(r'', 'cb_uqy', subcount[14]) + regexs[15].sub(r'', 'cb_uqy', subcount[15]) + regexs[14].sub(r'', 'hyJVzt', subcount[14]) + regexs[15].sub(r'', 'hyJVzt', subcount[15]) + regexs[8].search(r'144631658.0.10.1231363638') + regexs[8].search( + r'144631658.1231363638.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.965867047679498800.1231363638.1231363638.1231363638.1') + regexs[8].search(r'4413268q3660') + regexs[8].search(r'4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n') + regexs[8].search(r'SbeprqRkcvengvba=633669321699093060') + regexs[8].search(r'VC=74.125.75.20') + regexs[8].search(strings[19]) + regexs[8].search(strings[20]) + regexs[8].search(r'AFP_zp_tfwsbrg-aowb_80=4413268q3660') + regexs[8].search( + r'FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n') + regexs[8].search( + r'__hgzn=144631658.965867047679498800.1231363638.1231363638.1231363638.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231363638') + regexs[8].search( + r'__hgzm=144631658.1231363638.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[15]) + regexs[34].search(strings[16]) + + +def block4(): + for i in range(16): + re.sub(r'\*', '', '', 0) + re.search(r'\bnpgvir\b', 'npgvir') + re.search(r'sversbk', strings[0], re.IGNORECASE) + regexs[36].search(r'glcr') + re.search(r'zfvr', strings[0], re.IGNORECASE) + re.search(r'bcren', strings[0], re.IGNORECASE) + + for i in range(15): + regexs[32].split(strings[21]) + regexs[32].split(strings[22]) + regexs[12].sub( + r'', 'uggc://ohyyrgvaf.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[33].sub(r'', strings[23], subcount[33]) + regexs[37].sub(r'', 'yv', subcount[37]) + regexs[18].sub(r'', 'yv', subcount[18]) + regexs[8].search(r'144631658.0.10.1231367822') + regexs[8].search( + r'144631658.1231367822.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.4127520630321984500.1231367822.1231367822.1231367822.1') + regexs[8].search(strings[24]) + regexs[8].search(strings[25]) + regexs[8].search( + r'__hgzn=144631658.4127520630321984500.1231367822.1231367822.1231367822.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231367822') + regexs[8].search( + r'__hgzm=144631658.1231367822.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[21]) + regexs[34].search(strings[22]) + + # FIXME + # The \{0,65534} should be a * + # There's a current python bug that will stop the regex compilation + # when a * appears there http://bugs.python.org/issue6156. + re.search( + r'\.([\w-]+)|\[(\w+)(?:([!*^$~|]?=)["\']?(.*?)["\']?)?\]|:([\w-]+)(?:\(["\']?(.\{0,65534}?)?["\']?\)|$)', strings[26]) + + regexs[13].search(r'uggc://ohyyrgvaf.zlfcnpr.pbz/vaqrk.psz') + regexs[38].search(r'yv') + + for i in range(14): + regexs[18].sub(r'', '', subcount[18]) + re.sub(r'(\s+e|\s+o[0-9]+)', '', '9.0 e115', 1) + re.sub(r'<', '', 'Funer guvf tnqtrg', 0) + re.sub(r'>', '', 'Funer guvf tnqtrg', 0) + regexs[39].sub(r'', 'Funer guvf tnqtrg', subcount[39]) + regexs[12].sub( + r'', 'uggc://cebsvyrrqvg.zlfcnpr.pbz/vaqrk.psz', subcount[12]) + regexs[40].sub(r'', 'grnfre', subcount[40]) + regexs[41].sub(r'', 'grnfre', subcount[41]) + regexs[42].sub(r'', 'grnfre', subcount[42]) + regexs[43].sub(r'', 'grnfre', subcount[43]) + regexs[44].sub(r'', 'grnfre', subcount[44]) + regexs[45].sub(r'', 'grnfre', subcount[45]) + regexs[46].sub(r'', 'grnfre', subcount[46]) + regexs[47].sub(r'', 'grnfre', subcount[47]) + regexs[48].sub(r'', 'grnfre', subcount[48]) + regexs[16].search(r'znetva-gbc') + regexs[16].search(r'cbfvgvba') + regexs[19].search(r'gno1') + regexs[9].search(r'qz') + regexs[9].search(r'qg') + regexs[9].search(r'zbqobk') + regexs[9].search(r'zbqobkva') + regexs[9].search(r'zbqgvgyr') + regexs[13].search(r'uggc://cebsvyrrqvg.zlfcnpr.pbz/vaqrk.psz') + regexs[26].search(r'/vt/znvytnqtrg') + regexs[49].search(r'glcr') + + +def block5(): + for i in range(13): + regexs[14].sub(r'', 'purpx', subcount[14]) + regexs[15].sub(r'', 'purpx', subcount[15]) + regexs[14].sub(r'', 'pvgl', subcount[14]) + regexs[15].sub(r'', 'pvgl', subcount[15]) + regexs[14].sub(r'', 'qrpe fyvqrgrkg', subcount[14]) + regexs[15].sub(r'', 'qrpe fyvqrgrkg', subcount[15]) + regexs[14].sub(r'', 'svefg fryrpgrq', subcount[14]) + regexs[15].sub(r'', 'svefg fryrpgrq', subcount[15]) + regexs[14].sub(r'', 'uqy_rag', subcount[14]) + regexs[15].sub(r'', 'uqy_rag', subcount[15]) + regexs[14].sub(r'', 'vape fyvqrgrkg', subcount[14]) + regexs[15].sub(r'', 'vape fyvqrgrkg', subcount[15]) + regexs[5].sub(r'', 'vachggrkg QBZPbageby_cynprubyqre', subcount[5]) + regexs[14].sub( + r'', 'cnerag puebzr6 fvatyr1 gno fryrpgrq', subcount[14]) + regexs[15].sub( + r'', 'cnerag puebzr6 fvatyr1 gno fryrpgrq', subcount[15]) + regexs[14].sub(r'', 'cb_guz', subcount[14]) + regexs[15].sub(r'', 'cb_guz', subcount[15]) + regexs[14].sub(r'', 'fhozvg', subcount[14]) + regexs[15].sub(r'', 'fhozvg', subcount[15]) + regexs[50].search(r'') + re.search(r'NccyrJroXvg\/([^\s]*)', strings[0]) + re.search(r'XUGZY', strings[0]) + + for i in range(12): + re.sub(r'(\$\{cebg\})|(\$cebg\b)', '', + '${cebg}://${ubfg}${cngu}/${dz}', 0) + regexs[40].sub(r'', '1', subcount[40]) + regexs[10].sub(r'', '1', subcount[10]) + regexs[51].sub(r'', '1', subcount[51]) + regexs[52].sub(r'', '1', subcount[52]) + regexs[53].sub(r'', '1', subcount[53]) + regexs[39].sub(r'', '1', subcount[39]) + regexs[54].sub(r'', '1', subcount[54]) + re.sub(r'^(.*)\..*$', '', '9.0 e115', 1) + re.sub(r'^.*e(.*)$', '', '9.0 e115', 1) + regexs[55].sub(r'', '', subcount[55]) + regexs[55].sub( + r'', '', subcount[55]) + re.sub(r'^.*\s+(\S+\s+\S+$)', '', strings[1], 1) + regexs[30].sub(r'', 'tzk%2Subzrcntr%2Sfgneg%2Sqr%2S', subcount[30]) + regexs[30].sub(r'', 'tzk', subcount[30]) + re.sub(r'(\$\{ubfg\})|(\$ubfg\b)', '', + 'uggc://${ubfg}${cngu}/${dz}', 0) + regexs[56].sub( + r'', 'uggc://nqpyvrag.hvzfrei.arg${cngu}/${dz}', subcount[56]) + re.sub(r'(\$\{dz\})|(\$dz\b)', '', + 'uggc://nqpyvrag.hvzfrei.arg/wf.at/${dz}', 0) + regexs[29].sub(r'', 'frpgvba', subcount[29]) + regexs[30].sub(r'', 'frpgvba', subcount[30]) + regexs[29].sub(r'', 'fvgr', subcount[29]) + regexs[30].sub(r'', 'fvgr', subcount[30]) + regexs[29].sub(r'', 'fcrpvny', subcount[29]) + regexs[30].sub(r'', 'fcrpvny', subcount[30]) + regexs[36].search(r'anzr') + re.search(r'e', '9.0 e115') + + +def block6(): + for i in range(11): + re.sub(r'(?i)##yv0##', '', strings[27], 0) + regexs[57].sub(r'', strings[27], subcount[57]) + regexs[58].sub(r'', strings[28], subcount[58]) + regexs[59].sub(r'', strings[29], subcount[59]) + re.sub(r'(?i)##\/o##', '', strings[30], 0) + re.sub(r'(?i)##\/v##', '', strings[30], 0) + re.sub(r'(?i)##\/h##', '', strings[30], 0) + re.sub(r'(?i)##o##', '', strings[30], 0) + re.sub(r'(?i)##oe##', '', strings[30], 0) + re.sub(r'(?i)##v##', '', strings[30], 0) + re.sub(r'(?i)##h##', '', strings[30], 0) + re.sub(r'(?i)##n##', '', strings[31], 0) + re.sub(r'(?i)##\/n##', '', strings[32], 0) + + # This prints a unicode escape where the V8 version + # prints the unicode character. + re.sub(r'#~#argjbexybtb#~#', '', strings[33], 0) + + re.search(r' Zbovyr\/', strings[0]) + re.search(r'##yv1##', strings[27], re.IGNORECASE) + re.search(r'##yv10##', strings[28], re.IGNORECASE) + re.search(r'##yv11##', strings[28], re.IGNORECASE) + re.search(r'##yv12##', strings[28], re.IGNORECASE) + re.search(r'##yv13##', strings[28], re.IGNORECASE) + re.search(r'##yv14##', strings[28], re.IGNORECASE) + re.search(r'##yv15##', strings[28], re.IGNORECASE) + regexs[58].search(strings[28]) + re.search(r'##yv17##', strings[29], re.IGNORECASE) + re.search(r'##yv18##', strings[29], re.IGNORECASE) + regexs[59].search(strings[29]) + re.search(r'##yv2##', strings[27], re.IGNORECASE) + re.search(r'##yv20##', strings[30], re.IGNORECASE) + re.search(r'##yv21##', strings[30], re.IGNORECASE) + re.search(r'##yv22##', strings[30], re.IGNORECASE) + re.search(r'##yv23##', strings[30], re.IGNORECASE) + re.search(r'##yv3##', strings[27], re.IGNORECASE) + regexs[57].search(strings[27]) + re.search(r'##yv5##', strings[28], re.IGNORECASE) + re.search(r'##yv6##', strings[28], re.IGNORECASE) + re.search(r'##yv7##', strings[28], re.IGNORECASE) + re.search(r'##yv8##', strings[28], re.IGNORECASE) + re.search(r'##yv9##', strings[28], re.IGNORECASE) + regexs[8].search(r'473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29') + regexs[8].search(r'SbeprqRkcvengvba=633669325184628362') + regexs[8].search( + r'FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29') + re.search(r'AbxvnA[^\/]*', strings[0]) + + for i in range(10): + re.sub(r'(?:^|\s+)bss(?:\s+|$)', '', ' bss', 0) + re.sub(r'(\$\{0\})|(\$0\b)', '', strings[34], 0) + re.sub(r'(\$\{1\})|(\$1\b)', '', strings[34], 0) + re.sub(r'(\$\{pbzcyrgr\})|(\$pbzcyrgr\b)', '', strings[34], 0) + re.sub(r'(\$\{sentzrag\})|(\$sentzrag\b)', '', strings[34], 0) + re.sub(r'(\$\{ubfgcbeg\})|(\$ubfgcbeg\b)', '', strings[34], 0) + regexs[56].sub(r'', strings[34], subcount[56]) + re.sub(r'(\$\{cebgbpby\})|(\$cebgbpby\b)', '', strings[34], 0) + re.sub(r'(\$\{dhrel\})|(\$dhrel\b)', '', strings[34], 0) + regexs[29].sub(r'', 'nqfvmr', subcount[29]) + regexs[30].sub(r'', 'nqfvmr', subcount[30]) + re.sub(r'(\$\{2\})|(\$2\b)', '', 'uggc://${2}${3}${4}${5}', 0) + re.sub(r'(\$\{3\})|(\$3\b)', '', + 'uggc://wf.hv-cbegny.qr${3}${4}${5}', 0) + regexs[40].sub(r'', 'arjf', subcount[40]) + regexs[41].sub(r'', 'arjf', subcount[41]) + regexs[42].sub(r'', 'arjf', subcount[42]) + regexs[43].sub(r'', 'arjf', subcount[43]) + regexs[44].sub(r'', 'arjf', subcount[44]) + regexs[45].sub(r'', 'arjf', subcount[45]) + regexs[46].sub(r'', 'arjf', subcount[46]) + regexs[47].sub(r'', 'arjf', subcount[47]) + regexs[48].sub(r'', 'arjf', subcount[48]) + re.search(r' PC=i=(\d+)&oe=(.)', strings[35]) + regexs[60].search(r' ') + regexs[60].search(r' bss') + regexs[60].search(r'') + regexs[19].search(r' ') + regexs[19].search(r'svefg ba') + regexs[19].search(r'ynfg vtaber') + regexs[19].search(r'ba') + regexs[9].search(r'scnq so ') + regexs[9].search(r'zrqvgobk') + regexs[9].search(r'hsgy') + regexs[9].search(r'lhv-h') + re.search(r'Fnsnev|Xbadhrebe|XUGZY', strings[0], re.IGNORECASE) + regexs[61].search( + r'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf') + regexs[62].search(r'#Ybtva_rznvy') + + +def block7(): + for i in range(9): + regexs[40].sub(r'', '0', subcount[40]) + regexs[10].sub(r'', '0', subcount[10]) + regexs[51].sub(r'', '0', subcount[51]) + regexs[52].sub(r'', '0', subcount[52]) + regexs[53].sub(r'', '0', subcount[53]) + regexs[39].sub(r'', '0', subcount[39]) + regexs[54].sub(r'', '0', subcount[54]) + regexs[40].sub(r'', 'Lrf', subcount[40]) + regexs[10].sub(r'', 'Lrf', subcount[10]) + regexs[51].sub(r'', 'Lrf', subcount[51]) + regexs[52].sub(r'', 'Lrf', subcount[52]) + regexs[53].sub(r'', 'Lrf', subcount[53]) + regexs[39].sub(r'', 'Lrf', subcount[39]) + regexs[54].sub(r'', 'Lrf', subcount[54]) + + for i in range(8): + regexs[63].sub(r'', 'Pybfr {0}', subcount[63]) + regexs[63].sub(r'', 'Bcra {0}', subcount[63]) + regexs[32].split(strings[36]) + regexs[32].split(strings[37]) + regexs[14].sub(r'', 'puvyq p1 svefg gnournqref', subcount[14]) + regexs[15].sub(r'', 'puvyq p1 svefg gnournqref', subcount[15]) + regexs[14].sub(r'', 'uqy_fcb', subcount[14]) + regexs[15].sub(r'', 'uqy_fcb', subcount[15]) + regexs[14].sub(r'', 'uvag', subcount[14]) + regexs[15].sub(r'', 'uvag', subcount[15]) + regexs[33].sub(r'', strings[38], subcount[33]) + regexs[14].sub(r'', 'yvfg', subcount[14]) + regexs[15].sub(r'', 'yvfg', subcount[15]) + regexs[30].sub(r'', 'at_bhgre', subcount[30]) + regexs[14].sub(r'', 'cnerag puebzr5 qbhoyr2 NU', subcount[14]) + regexs[15].sub(r'', 'cnerag puebzr5 qbhoyr2 NU', subcount[15]) + regexs[14].sub( + r'', 'cnerag puebzr5 dhnq5 ps NU osyvax zbarl', subcount[14]) + regexs[15].sub( + r'', 'cnerag puebzr5 dhnq5 ps NU osyvax zbarl', subcount[15]) + regexs[14].sub(r'', 'cnerag puebzr6 fvatyr1', subcount[14]) + regexs[15].sub(r'', 'cnerag puebzr6 fvatyr1', subcount[15]) + regexs[14].sub(r'', 'cb_qrs', subcount[14]) + regexs[15].sub(r'', 'cb_qrs', subcount[15]) + regexs[14].sub(r'', 'gnopbagrag', subcount[14]) + regexs[15].sub(r'', 'gnopbagrag', subcount[15]) + regexs[30].sub(r'', 'iv_svefg_gvzr', subcount[30]) + re.search(r'(^|.)(ronl|qri-ehf3.wbg)(|fgberf|zbgbef|yvirnhpgvbaf|jvxv|rkcerff|punggre).(pbz(|.nh|.pa|.ux|.zl|.ft|.oe|.zk)|pb(.hx|.xe|.am)|pn|qr|se|vg|ay|or|ng|pu|vr|va|rf|cy|cu|fr)$', 'cntrf.ronl.pbz', re.IGNORECASE) + regexs[8].search(r'144631658.0.10.1231364074') + regexs[8].search( + r'144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.2294274870215848400.1231364074.1231364074.1231364074.1') + regexs[8].search(r'4413241q3660') + regexs[8].search(r'SbeprqRkcvengvba=633669357391353591') + regexs[8].search(strings[39]) + regexs[8].search(strings[40]) + regexs[8].search(r'AFP_zp_kkk-gdzogv_80=4413241q3660') + regexs[8].search( + r'FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7') + regexs[8].search( + r'__hgzn=144631658.2294274870215848400.1231364074.1231364074.1231364074.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231364074') + regexs[8].search( + r'__hgzm=144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search(r'p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7') + regexs[34].search(strings[36]) + regexs[34].search(strings[37]) + + +def block8(): + for i in range(7): + re.match(r'\d+', strings[1]) + regexs[64].sub(r'', 'nsgre', subcount[64]) + regexs[64].sub(r'', 'orsber', subcount[64]) + regexs[64].sub(r'', 'obggbz', subcount[64]) + regexs[65].sub(r'', 'ohvygva_jrngure.kzy', subcount[65]) + regexs[37].sub(r'', 'ohggba', subcount[37]) + regexs[18].sub(r'', 'ohggba', subcount[18]) + regexs[65].sub(r'', 'qngrgvzr.kzy', subcount[65]) + regexs[65].sub( + r'', 'uggc://eff.paa.pbz/eff/paa_gbcfgbevrf.eff', subcount[65]) + regexs[37].sub(r'', 'vachg', subcount[37]) + regexs[18].sub(r'', 'vachg', subcount[18]) + regexs[64].sub(r'', 'vafvqr', subcount[64]) + regexs[27].sub(r'', 'cbvagre', subcount[27]) + re.sub(r'[A-Z]', '', 'cbfvgvba', 0) + regexs[27].sub(r'', 'gbc', subcount[27]) + regexs[64].sub(r'', 'gbc', subcount[64]) + regexs[37].sub(r'', 'hy', subcount[37]) + regexs[18].sub(r'', 'hy', subcount[18]) + regexs[37].sub(r'', strings[26], subcount[37]) + regexs[18].sub(r'', strings[26], subcount[18]) + regexs[65].sub(r'', 'lbhghor_vtbbtyr/i2/lbhghor.kzy', subcount[65]) + regexs[27].sub(r'', 'm-vaqrk', subcount[27]) + re.search(r'#([\w-]+)', strings[26]) + regexs[16].search(r'urvtug') + regexs[16].search(r'znetvaGbc') + regexs[16].search(r'jvqgu') + regexs[19].search(r'gno0 svefg ba') + regexs[19].search(r'gno0 ba') + regexs[19].search(r'gno4 ynfg') + regexs[19].search(r'gno4') + regexs[19].search(r'gno5') + regexs[19].search(r'gno6') + regexs[19].search(r'gno7') + regexs[19].search(r'gno8') + re.search(r'NqborNVE\/([^\s]*)', strings[0]) + re.search(r'NccyrJroXvg\/([^ ]*)', strings[0]) + re.search(r'XUGZY', strings[0], re.IGNORECASE) + re.search(r'^(?:obql|ugzy)$', 'YV', re.IGNORECASE) + regexs[38].search(r'ohggba') + regexs[38].search(r'vachg') + regexs[38].search(r'hy') + regexs[38].search(strings[26]) + re.search(r'^(\w+|\*)', strings[26]) + re.search(r'znp|jva|yvahk', 'Jva32', re.IGNORECASE) + re.search(r'eton?\([\d\s,]+\)', 'fgngvp') + + for i in range(6): + re.sub(r'\r', '', '', 0) + regexs[40].sub(r'', '/', subcount[40]) + regexs[10].sub(r'', '/', subcount[10]) + regexs[51].sub(r'', '/', subcount[51]) + regexs[52].sub(r'', '/', subcount[52]) + regexs[53].sub(r'', '/', subcount[53]) + regexs[39].sub(r'', '/', subcount[39]) + regexs[54].sub(r'', '/', subcount[54]) + regexs[63].sub( + r'', 'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/{0}?[NDO]&{1}&{2}&[NDR]', subcount[63]) + regexs[12].sub(r'', strings[41], subcount[12]) + regexs[23].sub(r'', 'uggc://jjj.snprobbx.pbz/fepu.cuc', subcount[23]) + regexs[40].sub(r'', 'freivpr', subcount[40]) + regexs[41].sub(r'', 'freivpr', subcount[41]) + regexs[42].sub(r'', 'freivpr', subcount[42]) + regexs[43].sub(r'', 'freivpr', subcount[43]) + regexs[44].sub(r'', 'freivpr', subcount[44]) + regexs[45].sub(r'', 'freivpr', subcount[45]) + regexs[46].sub(r'', 'freivpr', subcount[46]) + regexs[47].sub(r'', 'freivpr', subcount[47]) + regexs[48].sub(r'', 'freivpr', subcount[48]) + re.search(r'((ZFVR\s+([6-9]|\d\d)\.))', strings[0]) + regexs[66].search(r'') + regexs[50].search(r'fryrpgrq') + regexs[8].search(r'8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn') + regexs[8].search(r'SbeprqRkcvengvba=633669340386893867') + regexs[8].search(r'VC=74.125.75.17') + regexs[8].search( + r'FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn') + re.search(r'Xbadhrebe|Fnsnev|XUGZY', strings[0]) + regexs[13].search(strings[41]) + regexs[49].search(r'unfsbphf') + + +def block9(): + for i in range(5): + regexs[32].split(strings[42]) + regexs[32].split(strings[43]) + regexs[20].split( + r'svz_zlfcnpr_hfre-ivrj-pbzzragf,svz_zlfcnpr_havgrq-fgngrf') + regexs[33].sub(r'', strings[44], subcount[33]) + regexs[67].sub( + r'', 'zrah_arj zrah_arj_gbttyr zrah_gbttyr', subcount[67]) + regexs[67].sub( + r'', 'zrah_byq zrah_byq_gbttyr zrah_gbttyr', subcount[67]) + regexs[8].search(r'102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98') + regexs[8].search(r'144631658.0.10.1231364380') + regexs[8].search( + r'144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.3931862196947939300.1231364380.1231364380.1231364380.1') + regexs[8].search(r'441326q33660') + regexs[8].search(r'SbeprqRkcvengvba=633669341278771470') + regexs[8].search(strings[45]) + regexs[8].search(strings[46]) + regexs[8].search(r'AFP_zp_dfctwzssrwh-aowb_80=441326q33660') + regexs[8].search( + r'FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98') + regexs[8].search( + r'__hgzn=144631658.3931862196947939300.1231364380.1231364380.1231364380.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231364380') + regexs[8].search( + r'__hgzm=144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + + for i in range(4): + regexs[14].sub(r'', ' yvfg1', subcount[14]) + regexs[15].sub(r'', ' yvfg1', subcount[15]) + regexs[14].sub(r'', ' yvfg2', subcount[14]) + regexs[15].sub(r'', ' yvfg2', subcount[15]) + regexs[14].sub(r'', ' frneputebhc1', subcount[14]) + regexs[15].sub(r'', ' frneputebhc1', subcount[15]) + regexs[68].sub(r'', strings[47], subcount[68]) + regexs[18].sub(r'', strings[47], subcount[18]) + re.sub(r'&', '', '', 0) + regexs[35].sub(r'', '', subcount[35]) + regexs[63].sub(r'', '(..-{0})(|(d+)|)', subcount[63]) + regexs[18].sub(r'', strings[48], subcount[18]) + regexs[56].sub( + r'', '//vzt.jro.qr/vij/FC/${cngu}/${anzr}/${inyhr}?gf=${abj}', subcount[56]) + re.sub(r'(\$\{anzr\})|(\$anzr\b)', '', + '//vzt.jro.qr/vij/FC/tzk_uc/${anzr}/${inyhr}?gf=${abj}', 0) + regexs[69].sub( + r'', 'Jvaqbjf Yvir Ubgznvy{1}', subcount[69]) + regexs[63].sub( + r'', '{0}{1}', subcount[63]) + regexs[69].sub( + r'', '{1}', subcount[69]) + regexs[63].sub( + r'', '{1}', subcount[63]) + regexs[15].sub(r'', 'Vzntrf', subcount[15]) + regexs[15].sub(r'', 'ZFA', subcount[15]) + regexs[15].sub(r'', 'Zncf', subcount[15]) + regexs[39].sub(r'', 'Zbq-Vasb-Vasb-WninFpevcgUvag', subcount[39]) + regexs[15].sub(r'', 'Arjf', subcount[15]) + regexs[32].split(strings[49]) + regexs[32].split(strings[50]) + regexs[15].sub(r'', 'Ivqrb', subcount[15]) + regexs[15].sub(r'', 'Jro', subcount[15]) + regexs[39].sub(r'', 'n', subcount[39]) + regexs[70].split(r'nwnkFgneg') + regexs[70].split(r'nwnkFgbc') + regexs[14].sub(r'', 'ovaq', subcount[14]) + regexs[15].sub(r'', 'ovaq', subcount[15]) + regexs[63].sub( + r'', 'oevatf lbh zber. Zber fcnpr (5TO), zber frphevgl, fgvyy serr.', subcount[63]) + regexs[14].sub(r'', 'puvyq p1 svefg qrpx', subcount[14]) + regexs[15].sub(r'', 'puvyq p1 svefg qrpx', subcount[15]) + regexs[14].sub(r'', 'puvyq p1 svefg qbhoyr2', subcount[14]) + regexs[15].sub(r'', 'puvyq p1 svefg qbhoyr2', subcount[15]) + regexs[14].sub(r'', 'puvyq p2 ynfg', subcount[14]) + regexs[15].sub(r'', 'puvyq p2 ynfg', subcount[15]) + regexs[14].sub(r'', 'puvyq p2', subcount[14]) + regexs[15].sub(r'', 'puvyq p2', subcount[15]) + regexs[14].sub(r'', 'puvyq p3', subcount[14]) + regexs[15].sub(r'', 'puvyq p3', subcount[15]) + regexs[14].sub(r'', 'puvyq p4 ynfg', subcount[14]) + regexs[15].sub(r'', 'puvyq p4 ynfg', subcount[15]) + regexs[14].sub(r'', 'pbclevtug', subcount[14]) + regexs[15].sub(r'', 'pbclevtug', subcount[15]) + regexs[14].sub(r'', 'qZFAZR_1', subcount[14]) + regexs[15].sub(r'', 'qZFAZR_1', subcount[15]) + regexs[14].sub(r'', 'qbhoyr2 ps', subcount[14]) + regexs[15].sub(r'', 'qbhoyr2 ps', subcount[15]) + regexs[14].sub(r'', 'qbhoyr2', subcount[14]) + regexs[15].sub(r'', 'qbhoyr2', subcount[15]) + regexs[14].sub(r'', 'uqy_arj', subcount[14]) + regexs[15].sub(r'', 'uqy_arj', subcount[15]) + regexs[30].sub(r'', 'uc_fubccvatobk', subcount[30]) + regexs[29].sub(r'', 'ugzy%2Rvq', subcount[29]) + regexs[30].sub(r'', 'ugzy%2Rvq', subcount[30]) + regexs[33].sub(r'', strings[51], subcount[33]) + regexs[71].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/cebgbglcr.wf${4}${5}', subcount[71]) + regexs[72].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/cebgbglcr.wf${5}', subcount[72]) + regexs[73].sub(r'', strings[52], subcount[73]) + regexs[69].sub( + r'', 'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55332979829981?[NDO]&{1}&{2}&[NDR]', subcount[69]) + regexs[14].sub(r'', 'vztZFSG', subcount[14]) + regexs[15].sub(r'', 'vztZFSG', subcount[15]) + regexs[14].sub(r'', 'zfasbbg1 ps', subcount[14]) + regexs[15].sub(r'', 'zfasbbg1 ps', subcount[15]) + regexs[14].sub(r'', strings[53], subcount[14]) + regexs[15].sub(r'', strings[53], subcount[15]) + regexs[14].sub( + r'', 'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq', subcount[14]) + regexs[15].sub( + r'', 'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq', subcount[15]) + regexs[14].sub(r'', 'cevznel', subcount[14]) + regexs[15].sub(r'', 'cevznel', subcount[15]) + regexs[30].sub(r'', 'erpgnatyr', subcount[30]) + regexs[14].sub(r'', 'frpbaqnel', subcount[14]) + regexs[15].sub(r'', 'frpbaqnel', subcount[15]) + regexs[70].split(r'haybnq') + regexs[63].sub(r'', '{0}{1}1', subcount[63]) + regexs[69].sub(r'', '|{1}1', subcount[69]) + re.search(r'(..-HF)(\|(\d+)|)', 'xb-xe,ra-va,gu-gu', re.IGNORECASE) + regexs[4].search(r'/ZlFcnprNccf/NccPnainf,45000012') + regexs[8].search(r'144631658.0.10.1231367708') + regexs[8].search( + r'144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.2770915348920628700.1231367708.1231367708.1231367708.1') + regexs[8].search(r'4413235p3660') + regexs[8].search(r'441327q73660') + regexs[8].search(r'9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473') + regexs[8].search(r'SbeprqRkcvengvba=633669350559478880') + regexs[8].search(strings[54]) + regexs[8].search(strings[55]) + regexs[8].search(r'AFP_zp_dfctwzs-aowb_80=441327q73660') + regexs[8].search(r'AFP_zp_kkk-aowb_80=4413235p3660') + regexs[8].search( + r'FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473') + regexs[8].search( + r'__hgzn=144631658.2770915348920628700.1231367708.1231367708.1231367708.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231367708') + regexs[8].search( + r'__hgzm=144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[49]) + regexs[34].search(strings[50]) + re.search(r'ZFVR\s+5[.]01', strings[0]) + re.search(r'HF(?=;)', strings[56], re.IGNORECASE) + regexs[74].search(strings[47]) + regexs[28].search(r'svefg npgvir svefgNpgvir') + regexs[28].search(r'ynfg') + re.search( + r'\bp:(..)', 'm:94043|yn:37.4154|yb:-122.0585|p:HF', re.IGNORECASE) + regexs[75].search(strings[57]) + regexs[75].search(strings[58]) + regexs[76].search(strings[57]) + regexs[76].search(strings[58]) + regexs[77].search(strings[57]) + regexs[77].search(strings[58]) + re.search(r'\bhfucce\s*=\s*([^;]*)', strings[59], re.IGNORECASE) + regexs[78].search(strings[57]) + regexs[78].search(strings[58]) + re.search(r'\bjci\s*=\s*([^;]*)', strings[59], re.IGNORECASE) + regexs[79].search(strings[58]) + regexs[79].search(strings[60]) + regexs[79].search(strings[59]) + re.search( + r'\|p:([a-z]{2})', 'm:94043|yn:37.4154|yb:-122.0585|p:HF|ue:1', re.IGNORECASE) + regexs[80].search(strings[47]) + regexs[61].search(r'cebgbglcr.wf') + regexs[68].search(strings[47]) + regexs[81].search(strings[47]) + regexs[82].search(strings[47]) + re.search(r'^Fubpxjnir Synfu (\d)', strings[1]) + re.search(r'^Fubpxjnir Synfu (\d+)', strings[1]) + regexs[83].search(r'[bowrpg tybony]') + regexs[62].search(strings[47]) + regexs[84].search(strings[61]) + regexs[84].search(strings[62]) + re.search(r'jroxvg', strings[63]) + + +def block10(): + for i in range(3): + regexs[39].sub(r'', '%3Szxg=ra-HF', subcount[39]) + regexs[40].sub(r'', '-8', subcount[40]) + regexs[10].sub(r'', '-8', subcount[10]) + regexs[51].sub(r'', '-8', subcount[51]) + regexs[52].sub(r'', '-8', subcount[52]) + regexs[53].sub(r'', '-8', subcount[53]) + regexs[39].sub(r'', '-8', subcount[39]) + regexs[54].sub(r'', '-8', subcount[54]) + regexs[40].sub(r'', '1.5', subcount[40]) + regexs[10].sub(r'', '1.5', subcount[10]) + regexs[51].sub(r'', '1.5', subcount[51]) + regexs[52].sub(r'', '1.5', subcount[52]) + regexs[53].sub(r'', '1.5', subcount[53]) + regexs[39].sub(r'', '1.5', subcount[39]) + regexs[54].sub(r'', '1.5', subcount[54]) + regexs[40].sub(r'', '1024k768', subcount[40]) + regexs[10].sub(r'', '1024k768', subcount[10]) + regexs[51].sub(r'', '1024k768', subcount[51]) + regexs[52].sub(r'', '1024k768', subcount[52]) + regexs[53].sub(r'', '1024k768', subcount[53]) + regexs[39].sub(r'', '1024k768', subcount[39]) + regexs[54].sub(r'', '1024k768', subcount[54]) + regexs[40].sub(r'', strings[64], subcount[40]) + regexs[10].sub(r'', strings[64], subcount[10]) + regexs[51].sub(r'', strings[64], subcount[51]) + regexs[52].sub(r'', strings[64], subcount[52]) + regexs[53].sub(r'', strings[64], subcount[53]) + regexs[39].sub(r'', strings[64], subcount[39]) + regexs[54].sub(r'', strings[64], subcount[54]) + regexs[40].sub(r'', '14', subcount[40]) + regexs[10].sub(r'', '14', subcount[10]) + regexs[51].sub(r'', '14', subcount[51]) + regexs[52].sub(r'', '14', subcount[52]) + regexs[53].sub(r'', '14', subcount[53]) + regexs[39].sub(r'', '14', subcount[39]) + regexs[54].sub(r'', '14', subcount[54]) + regexs[40].sub(r'', '24', subcount[40]) + regexs[10].sub(r'', '24', subcount[10]) + regexs[51].sub(r'', '24', subcount[51]) + regexs[52].sub(r'', '24', subcount[52]) + regexs[53].sub(r'', '24', subcount[53]) + regexs[39].sub(r'', '24', subcount[39]) + regexs[54].sub(r'', '24', subcount[54]) + regexs[40].sub(r'', strings[65], subcount[40]) + regexs[10].sub(r'', strings[65], subcount[10]) + regexs[51].sub(r'', strings[65], subcount[51]) + regexs[52].sub(r'', strings[65], subcount[52]) + regexs[53].sub(r'', strings[65], subcount[53]) + regexs[39].sub(r'', strings[65], subcount[39]) + regexs[54].sub(r'', strings[65], subcount[54]) + regexs[40].sub(r'', strings[66], subcount[40]) + regexs[10].sub(r'', strings[66], subcount[10]) + regexs[51].sub(r'', strings[66], subcount[51]) + regexs[52].sub(r'', strings[66], subcount[52]) + regexs[53].sub(r'', strings[66], subcount[53]) + regexs[39].sub(r'', strings[66], subcount[39]) + regexs[54].sub(r'', strings[66], subcount[54]) + regexs[40].sub(r'', '9.0', subcount[40]) + regexs[10].sub(r'', '9.0', subcount[10]) + regexs[51].sub(r'', '9.0', subcount[51]) + regexs[52].sub(r'', '9.0', subcount[52]) + regexs[53].sub(r'', '9.0', subcount[53]) + regexs[39].sub(r'', '9.0', subcount[39]) + regexs[54].sub(r'', '9.0', subcount[54]) + regexs[40].sub(r'', '994k634', subcount[40]) + regexs[10].sub(r'', '994k634', subcount[10]) + regexs[51].sub(r'', '994k634', subcount[51]) + regexs[52].sub(r'', '994k634', subcount[52]) + regexs[53].sub(r'', '994k634', subcount[53]) + regexs[39].sub(r'', '994k634', subcount[39]) + regexs[54].sub(r'', '994k634', subcount[54]) + regexs[40].sub(r'', '?zxg=ra-HF', subcount[40]) + regexs[10].sub(r'', '?zxg=ra-HF', subcount[10]) + regexs[51].sub(r'', '?zxg=ra-HF', subcount[51]) + regexs[52].sub(r'', '?zxg=ra-HF', subcount[52]) + regexs[53].sub(r'', '?zxg=ra-HF', subcount[53]) + regexs[54].sub(r'', '?zxg=ra-HF', subcount[54]) + regexs[25].sub(r'', 'PAA.pbz', subcount[25]) + regexs[12].sub(r'', 'PAA.pbz', subcount[12]) + regexs[39].sub(r'', 'PAA.pbz', subcount[39]) + regexs[25].sub(r'', 'Qngr & Gvzr', subcount[25]) + regexs[12].sub(r'', 'Qngr & Gvzr', subcount[12]) + regexs[39].sub(r'', 'Qngr & Gvzr', subcount[39]) + regexs[40].sub(r'', 'Frnepu Zvpebfbsg.pbz', subcount[40]) + regexs[54].sub(r'', 'Frnepu Zvpebfbsg.pbz', subcount[54]) + regexs[10].sub(r'', strings[67], subcount[10]) + regexs[51].sub(r'', strings[67], subcount[51]) + regexs[52].sub(r'', strings[67], subcount[52]) + regexs[53].sub(r'', strings[67], subcount[53]) + regexs[39].sub(r'', strings[67], subcount[39]) + regexs[32].split(strings[68]) + regexs[32].split(strings[69]) + regexs[52].sub(r'', strings[70], subcount[52]) + regexs[53].sub(r'', strings[70], subcount[53]) + regexs[39].sub(r'', strings[70], subcount[39]) + regexs[40].sub(r'', strings[71], subcount[40]) + regexs[10].sub(r'', strings[71], subcount[10]) + regexs[51].sub(r'', strings[71], subcount[51]) + regexs[54].sub(r'', strings[71], subcount[54]) + regexs[25].sub(r'', 'Jrngure', subcount[25]) + regexs[12].sub(r'', 'Jrngure', subcount[12]) + regexs[39].sub(r'', 'Jrngure', subcount[39]) + regexs[25].sub(r'', 'LbhGhor', subcount[25]) + regexs[12].sub(r'', 'LbhGhor', subcount[12]) + regexs[39].sub(r'', 'LbhGhor', subcount[39]) + regexs[33].sub(r'', strings[72], subcount[33]) + re.sub(r'^erzbgr_vsenzr_', '', 'erzbgr_vsenzr_1', 1) + regexs[40].sub(r'', strings[73], subcount[40]) + regexs[10].sub(r'', strings[73], subcount[10]) + regexs[51].sub(r'', strings[73], subcount[51]) + regexs[52].sub(r'', strings[73], subcount[52]) + regexs[53].sub(r'', strings[73], subcount[53]) + regexs[39].sub(r'', strings[73], subcount[39]) + regexs[54].sub(r'', strings[73], subcount[54]) + regexs[40].sub(r'', strings[74], subcount[40]) + regexs[10].sub(r'', strings[74], subcount[10]) + regexs[51].sub(r'', strings[74], subcount[51]) + regexs[52].sub(r'', strings[74], subcount[52]) + regexs[53].sub(r'', strings[74], subcount[53]) + regexs[39].sub(r'', strings[74], subcount[39]) + regexs[54].sub(r'', strings[74], subcount[54]) + re.sub(r'\-', '', 'lhv-h', 0) + regexs[9].search(r'p') + regexs[9].search(r'qz p') + regexs[9].search(r'zbqynory') + regexs[9].search(r'lhv-h svefg') + regexs[8].search(r'144631658.0.10.1231365779') + regexs[8].search( + r'144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.1877536177953918500.1231365779.1231365779.1231365779.1') + regexs[8].search(strings[75]) + regexs[8].search(strings[76]) + regexs[8].search( + r'__hgzn=144631658.1877536177953918500.1231365779.1231365779.1231365779.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231365779') + regexs[8].search( + r'__hgzm=144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[68]) + regexs[34].search(strings[69]) + re.search(r'^$', '') + regexs[31].search(r'qr') + re.search(r'^znk\d+$', '') + re.search(r'^zva\d+$', '') + re.search(r'^erfgber$', '') + regexs[85].search(r'zbqobkva zbqobk_abcnqqvat ') + regexs[85].search(r'zbqgvgyr') + regexs[85].search(r'eaq_zbqobkva ') + regexs[85].search(r'eaq_zbqgvgyr ') + re.search(r'frpgvba\d+_pbagragf', 'obggbz_ani') + + +def block11(): + for i in range(2): + regexs[18].sub(r'', ' .pybfr', subcount[18]) + regexs[18].sub(r'', ' n.svryqOgaPnapry', subcount[18]) + regexs[18].sub(r'', ' qg', subcount[18]) + regexs[68].sub(r'', strings[77], subcount[68]) + regexs[18].sub(r'', strings[77], subcount[18]) + regexs[39].sub(r'', '', subcount[39]) + re.sub(r'^', '', '', 1) + regexs[86].split(r'') + regexs[39].sub(r'', '*', subcount[39]) + regexs[68].sub(r'', '*', subcount[68]) + regexs[18].sub(r'', '*', subcount[18]) + regexs[68].sub(r'', '.pybfr', subcount[68]) + regexs[18].sub(r'', '.pybfr', subcount[18]) + regexs[87].sub( + r'', '//vzt.jro.qr/vij/FC/tzk_uc/fperra/${inyhr}?gf=${abj}', subcount[87]) + regexs[88].sub( + r'', '//vzt.jro.qr/vij/FC/tzk_uc/fperra/1024?gf=${abj}', subcount[88]) + regexs[87].sub( + r'', '//vzt.jro.qr/vij/FC/tzk_uc/jvafvmr/${inyhr}?gf=${abj}', subcount[87]) + regexs[88].sub( + r'', '//vzt.jro.qr/vij/FC/tzk_uc/jvafvmr/992/608?gf=${abj}', subcount[88]) + regexs[30].sub(r'', '300k120', subcount[30]) + regexs[30].sub(r'', '300k250', subcount[30]) + regexs[30].sub(r'', '310k120', subcount[30]) + regexs[30].sub(r'', '310k170', subcount[30]) + regexs[30].sub(r'', '310k250', subcount[30]) + re.sub(r'^.*\.(.*)\s.*$', '', '9.0 e115', 1) + regexs[2].sub(r'', 'Nppbeqvba', subcount[2]) + regexs[89].sub(r'', 'Nxghryy\x0a', subcount[89]) + regexs[90].sub(r'', 'Nxghryy\x0a', subcount[90]) + regexs[2].sub(r'', 'Nccyvpngvba', subcount[2]) + regexs[89].sub(r'', 'Oyvpxchaxg\x0a', subcount[89]) + regexs[90].sub(r'', 'Oyvpxchaxg\x0a', subcount[90]) + regexs[89].sub(r'', 'Svanamra\x0a', subcount[89]) + regexs[90].sub(r'', 'Svanamra\x0a', subcount[90]) + regexs[89].sub(r'', 'Tnzrf\x0a', subcount[89]) + regexs[90].sub(r'', 'Tnzrf\x0a', subcount[90]) + regexs[89].sub(r'', 'Ubebfxbc\x0a', subcount[89]) + regexs[90].sub(r'', 'Ubebfxbc\x0a', subcount[90]) + regexs[89].sub(r'', 'Xvab\x0a', subcount[89]) + regexs[90].sub(r'', 'Xvab\x0a', subcount[90]) + regexs[2].sub(r'', 'Zbqhyrf', subcount[2]) + regexs[89].sub(r'', 'Zhfvx\x0a', subcount[89]) + regexs[90].sub(r'', 'Zhfvx\x0a', subcount[90]) + regexs[89].sub(r'', 'Anpuevpugra\x0a', subcount[89]) + regexs[90].sub(r'', 'Anpuevpugra\x0a', subcount[90]) + regexs[2].sub(r'', 'Cuk', subcount[2]) + regexs[70].split(r'ErdhrfgSvavfu') + regexs[70].split(r'ErdhrfgSvavfu.NWNK.Cuk') + regexs[89].sub(r'', 'Ebhgr\x0a', subcount[89]) + regexs[90].sub(r'', 'Ebhgr\x0a', subcount[90]) + regexs[32].split(strings[78]) + regexs[32].split(strings[79]) + regexs[32].split(strings[80]) + regexs[32].split(strings[81]) + regexs[89].sub(r'', 'Fcbeg\x0a', subcount[89]) + regexs[90].sub(r'', 'Fcbeg\x0a', subcount[90]) + regexs[89].sub(r'', 'GI-Fcbg\x0a', subcount[89]) + regexs[90].sub(r'', 'GI-Fcbg\x0a', subcount[90]) + regexs[89].sub(r'', 'Gbhe\x0a', subcount[89]) + regexs[90].sub(r'', 'Gbhe\x0a', subcount[90]) + regexs[89].sub(r'', 'Hagreunyghat\x0a', subcount[89]) + regexs[90].sub(r'', 'Hagreunyghat\x0a', subcount[90]) + regexs[89].sub(r'', 'Ivqrb\x0a', subcount[89]) + regexs[90].sub(r'', 'Ivqrb\x0a', subcount[90]) + regexs[89].sub(r'', 'Jrggre\x0a', subcount[89]) + regexs[90].sub(r'', 'Jrggre\x0a', subcount[90]) + regexs[68].sub(r'', strings[82], subcount[68]) + regexs[18].sub(r'', strings[82], subcount[18]) + regexs[68].sub(r'', strings[83], subcount[68]) + regexs[18].sub(r'', strings[83], subcount[18]) + regexs[68].sub(r'', strings[84], subcount[68]) + regexs[18].sub(r'', strings[84], subcount[18]) + regexs[30].sub(r'', 'nqiFreivprObk', subcount[30]) + regexs[30].sub(r'', 'nqiFubccvatObk', subcount[30]) + regexs[39].sub(r'', 'nwnk', subcount[39]) + regexs[40].sub(r'', 'nxghryy', subcount[40]) + regexs[41].sub(r'', 'nxghryy', subcount[41]) + regexs[42].sub(r'', 'nxghryy', subcount[42]) + regexs[43].sub(r'', 'nxghryy', subcount[43]) + regexs[44].sub(r'', 'nxghryy', subcount[44]) + regexs[45].sub(r'', 'nxghryy', subcount[45]) + regexs[46].sub(r'', 'nxghryy', subcount[46]) + regexs[47].sub(r'', 'nxghryy', subcount[47]) + regexs[48].sub(r'', 'nxghryy', subcount[48]) + regexs[40].sub(r'', strings[85], subcount[40]) + regexs[41].sub(r'', strings[85], subcount[41]) + regexs[42].sub(r'', strings[85], subcount[42]) + regexs[43].sub(r'', strings[85], subcount[43]) + regexs[44].sub(r'', strings[85], subcount[44]) + regexs[45].sub(r'', strings[85], subcount[45]) + regexs[46].sub(r'', strings[85], subcount[46]) + regexs[47].sub(r'', strings[85], subcount[47]) + regexs[48].sub(r'', strings[85], subcount[48]) + regexs[29].sub(r'', 'pngrtbel', subcount[29]) + regexs[30].sub(r'', 'pngrtbel', subcount[30]) + regexs[39].sub(r'', 'pybfr', subcount[39]) + regexs[39].sub(r'', 'qvi', subcount[39]) + regexs[68].sub(r'', strings[86], subcount[68]) + regexs[18].sub(r'', strings[86], subcount[18]) + regexs[39].sub(r'', 'qg', subcount[39]) + regexs[68].sub(r'', 'qg', subcount[68]) + regexs[18].sub(r'', 'qg', subcount[18]) + regexs[39].sub(r'', 'rzorq', subcount[39]) + regexs[68].sub(r'', 'rzorq', subcount[68]) + regexs[18].sub(r'', 'rzorq', subcount[18]) + regexs[39].sub(r'', 'svryqOga', subcount[39]) + regexs[39].sub(r'', 'svryqOgaPnapry', subcount[39]) + regexs[20].split(r'svz_zlfcnpr_nccf-pnainf,svz_zlfcnpr_havgrq-fgngrf') + regexs[40].sub(r'', 'svanamra', subcount[40]) + regexs[41].sub(r'', 'svanamra', subcount[41]) + regexs[42].sub(r'', 'svanamra', subcount[42]) + regexs[43].sub(r'', 'svanamra', subcount[43]) + regexs[44].sub(r'', 'svanamra', subcount[44]) + regexs[45].sub(r'', 'svanamra', subcount[45]) + regexs[46].sub(r'', 'svanamra', subcount[46]) + regexs[47].sub(r'', 'svanamra', subcount[47]) + regexs[48].sub(r'', 'svanamra', subcount[48]) + regexs[70].split(r'sbphf') + regexs[70].split(r'sbphf.gno sbphfva.gno') + regexs[70].split(r'sbphfva') + regexs[39].sub(r'', 'sbez', subcount[39]) + regexs[68].sub(r'', 'sbez.nwnk', subcount[68]) + regexs[18].sub(r'', 'sbez.nwnk', subcount[18]) + regexs[40].sub(r'', 'tnzrf', subcount[40]) + regexs[41].sub(r'', 'tnzrf', subcount[41]) + regexs[42].sub(r'', 'tnzrf', subcount[42]) + regexs[43].sub(r'', 'tnzrf', subcount[43]) + regexs[44].sub(r'', 'tnzrf', subcount[44]) + regexs[45].sub(r'', 'tnzrf', subcount[45]) + regexs[46].sub(r'', 'tnzrf', subcount[46]) + regexs[47].sub(r'', 'tnzrf', subcount[47]) + regexs[48].sub(r'', 'tnzrf', subcount[48]) + regexs[30].sub(r'', 'ubzrcntr', subcount[30]) + regexs[40].sub(r'', 'ubebfxbc', subcount[40]) + regexs[41].sub(r'', 'ubebfxbc', subcount[41]) + regexs[42].sub(r'', 'ubebfxbc', subcount[42]) + regexs[43].sub(r'', 'ubebfxbc', subcount[43]) + regexs[44].sub(r'', 'ubebfxbc', subcount[44]) + regexs[45].sub(r'', 'ubebfxbc', subcount[45]) + regexs[46].sub(r'', 'ubebfxbc', subcount[46]) + regexs[47].sub(r'', 'ubebfxbc', subcount[47]) + regexs[48].sub(r'', 'ubebfxbc', subcount[48]) + regexs[30].sub(r'', 'uc_cebzbobk_ugzy%2Puc_cebzbobk_vzt', subcount[30]) + regexs[30].sub(r'', 'uc_erpgnatyr', subcount[30]) + regexs[33].sub(r'', strings[87], subcount[33]) + regexs[33].sub(r'', strings[88], subcount[33]) + regexs[71].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf${4}${5}', subcount[71]) + regexs[72].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf${5}', subcount[72]) + regexs[71].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/qlaYvo.wf${4}${5}', subcount[71]) + regexs[72].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/qlaYvo.wf${5}', subcount[72]) + regexs[71].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/rssrpgYvo.wf${4}${5}', subcount[71]) + regexs[72].sub( + r'', 'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/rssrpgYvo.wf${5}', subcount[72]) + regexs[73].sub(r'', strings[89], subcount[73]) + regexs[69].sub( + r'', 'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55023338617756?[NDO]&{1}&{2}&[NDR]', subcount[69]) + regexs[23].sub(r'', strings[6], subcount[23]) + regexs[40].sub(r'', 'xvab', subcount[40]) + regexs[41].sub(r'', 'xvab', subcount[41]) + regexs[42].sub(r'', 'xvab', subcount[42]) + regexs[43].sub(r'', 'xvab', subcount[43]) + regexs[44].sub(r'', 'xvab', subcount[44]) + regexs[45].sub(r'', 'xvab', subcount[45]) + regexs[46].sub(r'', 'xvab', subcount[46]) + regexs[47].sub(r'', 'xvab', subcount[47]) + regexs[48].sub(r'', 'xvab', subcount[48]) + regexs[70].split(r'ybnq') + regexs[18].sub( + r'', 'zrqvnzbqgno lhv-anifrg lhv-anifrg-gbc', subcount[18]) + regexs[39].sub(r'', 'zrgn', subcount[39]) + regexs[68].sub(r'', strings[90], subcount[68]) + regexs[18].sub(r'', strings[90], subcount[18]) + regexs[70].split(r'zbhfrzbir') + regexs[70].split(r'zbhfrzbir.gno') + re.sub(r'^.*jroxvg\/(\d+(\.\d+)?).*$', '', strings[63], 1) + regexs[40].sub(r'', 'zhfvx', subcount[40]) + regexs[41].sub(r'', 'zhfvx', subcount[41]) + regexs[42].sub(r'', 'zhfvx', subcount[42]) + regexs[43].sub(r'', 'zhfvx', subcount[43]) + regexs[44].sub(r'', 'zhfvx', subcount[44]) + regexs[45].sub(r'', 'zhfvx', subcount[45]) + regexs[46].sub(r'', 'zhfvx', subcount[46]) + regexs[47].sub(r'', 'zhfvx', subcount[47]) + regexs[48].sub(r'', 'zhfvx', subcount[48]) + regexs[52].sub(r'', 'zlfcnpr_nccf_pnainf', subcount[52]) + regexs[40].sub(r'', strings[91], subcount[40]) + regexs[41].sub(r'', strings[91], subcount[41]) + regexs[42].sub(r'', strings[91], subcount[42]) + regexs[43].sub(r'', strings[91], subcount[43]) + regexs[44].sub(r'', strings[91], subcount[44]) + regexs[45].sub(r'', strings[91], subcount[45]) + regexs[46].sub(r'', strings[91], subcount[46]) + regexs[47].sub(r'', strings[91], subcount[47]) + regexs[48].sub(r'', strings[91], subcount[48]) + regexs[39].sub(r'', 'anzr', subcount[39]) + + # This prints something different to the V8 version + # The V8 version is escaping different things in the string that + # has the substitutions performed on it. + # + # V8 treats /\S/ like / + escaped S + / + # Python treats it like / + \ + S + / + re.sub(r'\b\w+\b', '', strings[92], 0) + + regexs[39].sub(r'', 'bow-nppbeqvba', subcount[39]) + regexs[39].sub(r'', 'bowrpg', subcount[39]) + regexs[68].sub(r'', 'bowrpg', subcount[68]) + regexs[18].sub(r'', 'bowrpg', subcount[18]) + regexs[29].sub(r'', 'cnenzf%2Rfglyrf', subcount[29]) + regexs[30].sub(r'', 'cnenzf%2Rfglyrf', subcount[30]) + regexs[30].sub(r'', 'cbchc', subcount[30]) + regexs[40].sub(r'', 'ebhgr', subcount[40]) + regexs[41].sub(r'', 'ebhgr', subcount[41]) + regexs[42].sub(r'', 'ebhgr', subcount[42]) + regexs[43].sub(r'', 'ebhgr', subcount[43]) + regexs[44].sub(r'', 'ebhgr', subcount[44]) + regexs[45].sub(r'', 'ebhgr', subcount[45]) + regexs[46].sub(r'', 'ebhgr', subcount[46]) + regexs[47].sub(r'', 'ebhgr', subcount[47]) + regexs[48].sub(r'', 'ebhgr', subcount[48]) + regexs[30].sub(r'', 'freivprobk_uc', subcount[30]) + regexs[30].sub(r'', 'fubccvatobk_uc', subcount[30]) + regexs[39].sub(r'', 'fubhgobk', subcount[39]) + regexs[40].sub(r'', 'fcbeg', subcount[40]) + regexs[41].sub(r'', 'fcbeg', subcount[41]) + regexs[42].sub(r'', 'fcbeg', subcount[42]) + regexs[43].sub(r'', 'fcbeg', subcount[43]) + regexs[44].sub(r'', 'fcbeg', subcount[44]) + regexs[45].sub(r'', 'fcbeg', subcount[45]) + regexs[46].sub(r'', 'fcbeg', subcount[46]) + regexs[47].sub(r'', 'fcbeg', subcount[47]) + regexs[48].sub(r'', 'fcbeg', subcount[48]) + regexs[40].sub(r'', 'gbhe', subcount[40]) + regexs[41].sub(r'', 'gbhe', subcount[41]) + regexs[42].sub(r'', 'gbhe', subcount[42]) + regexs[43].sub(r'', 'gbhe', subcount[43]) + regexs[44].sub(r'', 'gbhe', subcount[44]) + regexs[45].sub(r'', 'gbhe', subcount[45]) + regexs[46].sub(r'', 'gbhe', subcount[46]) + regexs[47].sub(r'', 'gbhe', subcount[47]) + regexs[48].sub(r'', 'gbhe', subcount[48]) + regexs[40].sub(r'', 'gi-fcbg', subcount[40]) + regexs[41].sub(r'', 'gi-fcbg', subcount[41]) + regexs[42].sub(r'', 'gi-fcbg', subcount[42]) + regexs[43].sub(r'', 'gi-fcbg', subcount[43]) + regexs[44].sub(r'', 'gi-fcbg', subcount[44]) + regexs[45].sub(r'', 'gi-fcbg', subcount[45]) + regexs[46].sub(r'', 'gi-fcbg', subcount[46]) + regexs[47].sub(r'', 'gi-fcbg', subcount[47]) + regexs[48].sub(r'', 'gi-fcbg', subcount[48]) + regexs[39].sub(r'', 'glcr', subcount[39]) + re.sub(r'\/', '', 'haqrsvarq', 0) + regexs[40].sub(r'', strings[93], subcount[40]) + regexs[41].sub(r'', strings[93], subcount[41]) + regexs[42].sub(r'', strings[93], subcount[42]) + regexs[43].sub(r'', strings[93], subcount[43]) + regexs[44].sub(r'', strings[93], subcount[44]) + regexs[45].sub(r'', strings[93], subcount[45]) + regexs[46].sub(r'', strings[93], subcount[46]) + regexs[47].sub(r'', strings[93], subcount[47]) + regexs[48].sub(r'', strings[93], subcount[48]) + regexs[40].sub(r'', 'ivqrb', subcount[40]) + regexs[41].sub(r'', 'ivqrb', subcount[41]) + regexs[42].sub(r'', 'ivqrb', subcount[42]) + regexs[43].sub(r'', 'ivqrb', subcount[43]) + regexs[44].sub(r'', 'ivqrb', subcount[44]) + regexs[45].sub(r'', 'ivqrb', subcount[45]) + regexs[46].sub(r'', 'ivqrb', subcount[46]) + regexs[47].sub(r'', 'ivqrb', subcount[47]) + regexs[48].sub(r'', 'ivqrb', subcount[48]) + regexs[86].split(r'ivfvgf=1') + regexs[40].sub(r'', 'jrggre', subcount[40]) + regexs[41].sub(r'', 'jrggre', subcount[41]) + regexs[42].sub(r'', 'jrggre', subcount[42]) + regexs[43].sub(r'', 'jrggre', subcount[43]) + regexs[44].sub(r'', 'jrggre', subcount[44]) + regexs[45].sub(r'', 'jrggre', subcount[45]) + regexs[46].sub(r'', 'jrggre', subcount[46]) + regexs[47].sub(r'', 'jrggre', subcount[47]) + regexs[48].sub(r'', 'jrggre', subcount[48]) + re.search(r'#[a-z0-9]+$', + 'uggc://jjj.fpuhryreim.arg/Qrsnhyg', re.IGNORECASE) + regexs[66].search(r'fryrpgrq') + re.search(r'(?:^|\s+)lhv-ani(?:\s+|$)', 'sff lhv-ani') + re.search(r'(?:^|\s+)lhv-anifrg(?:\s+|$)', 'zrqvnzbqgno lhv-anifrg') + re.search(r'(?:^|\s+)lhv-anifrg-gbc(?:\s+|$)', + 'zrqvnzbqgno lhv-anifrg') + regexs[91].search(r'GnoThvq') + regexs[91].search(r'thvq') + re.search(r'(pbzcngvoyr|jroxvg)', strings[63]) + re.search(r'.+(?:ei|vg|en|vr)[\/: ]([\d.]+)', strings[63]) + regexs[8].search(r'144631658.0.10.1231365869') + regexs[8].search(r'144631658.0.10.1231367054') + regexs[8].search( + r'144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'144631658.1670816052019209000.1231365869.1231365869.1231365869.1') + regexs[8].search( + r'144631658.1796080716621419500.1231367054.1231367054.1231367054.1') + regexs[8].search(strings[94]) + regexs[8].search(strings[95]) + regexs[8].search(strings[96]) + regexs[8].search(strings[97]) + regexs[8].search( + r'__hgzn=144631658.1670816052019209000.1231365869.1231365869.1231365869.1') + regexs[8].search( + r'__hgzn=144631658.1796080716621419500.1231367054.1231367054.1231367054.1') + regexs[8].search(r'__hgzo=144631658.0.10.1231365869') + regexs[8].search(r'__hgzo=144631658.0.10.1231367054') + regexs[8].search( + r'__hgzm=144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[8].search( + r'__hgzm=144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)') + regexs[34].search(strings[78]) + regexs[34].search(strings[79]) + regexs[34].search(strings[81]) + regexs[74].search(strings[77]) + regexs[74].search(r'*') + regexs[74].search(strings[82]) + regexs[74].search(strings[83]) + regexs[74].search(strings[86]) + regexs[74].search(r'rzorq') + regexs[74].search(r'sbez.nwnk') + regexs[74].search(strings[90]) + regexs[74].search(r'bowrpg') + re.search(r'\/onfr.wf(\?.+)?$', + '/uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf') + regexs[28].search(r'uvag ynfgUvag ynfg') + regexs[75].search(r'') + regexs[76].search(r'') + regexs[77].search(r'') + regexs[78].search(r'') + regexs[80].search(strings[77]) + regexs[80].search(r'*') + regexs[80].search(r'.pybfr') + regexs[80].search(strings[82]) + regexs[80].search(strings[83]) + regexs[80].search(strings[84]) + regexs[80].search(strings[86]) + regexs[80].search(r'qg') + regexs[80].search(r'rzorq') + regexs[80].search(r'sbez.nwnk') + regexs[80].search(strings[90]) + regexs[80].search(r'bowrpg') + regexs[61].search(r'qlaYvo.wf') + regexs[61].search(r'rssrpgYvo.wf') + regexs[61].search(r'uggc://jjj.tzk.arg/qr/?fgnghf=uvajrvf') + regexs[92].search(r' .pybfr') + regexs[92].search(r' n.svryqOgaPnapry') + regexs[92].search(r' qg') + regexs[92].search(strings[48]) + regexs[92].search(r'.nwnk') + regexs[92].search(r'.svryqOga,n.svryqOgaPnapry') + regexs[92].search(r'.svryqOgaPnapry') + regexs[92].search(r'.bow-nppbeqvba qg') + regexs[68].search(strings[77]) + regexs[68].search(r'*') + regexs[68].search(r'.pybfr') + regexs[68].search(strings[82]) + regexs[68].search(strings[83]) + regexs[68].search(strings[84]) + regexs[68].search(strings[86]) + regexs[68].search(r'qg') + regexs[68].search(r'rzorq') + regexs[68].search(r'sbez.nwnk') + regexs[68].search(strings[90]) + regexs[68].search(r'bowrpg') + regexs[93].search(r' .pybfr') + regexs[93].search(r' n.svryqOgaPnapry') + regexs[93].search(r' qg') + regexs[93].search(strings[48]) + regexs[93].search(r'.nwnk') + regexs[93].search(r'.svryqOga,n.svryqOgaPnapry') + regexs[93].search(r'.svryqOgaPnapry') + regexs[93].search(r'.bow-nppbeqvba qg') + regexs[81].search(strings[77]) + regexs[81].search(r'*') + regexs[81].search(strings[48]) + regexs[81].search(r'.pybfr') + regexs[81].search(strings[82]) + regexs[81].search(strings[83]) + regexs[81].search(strings[84]) + regexs[81].search(strings[86]) + regexs[81].search(r'qg') + regexs[81].search(r'rzorq') + regexs[81].search(r'sbez.nwnk') + regexs[81].search(strings[90]) + regexs[81].search(r'bowrpg') + regexs[94].search(r' .pybfr') + regexs[94].search(r' n.svryqOgaPnapry') + regexs[94].search(r' qg') + regexs[94].search(strings[48]) + regexs[94].search(r'.nwnk') + regexs[94].search(r'.svryqOga,n.svryqOgaPnapry') + regexs[94].search(r'.svryqOgaPnapry') + regexs[94].search(r'.bow-nppbeqvba qg') + regexs[94].search(r'[anzr=nwnkHey]') + regexs[94].search(strings[82]) + regexs[31].search(r'rf') + regexs[31].search(r'wn') + regexs[82].search(strings[77]) + regexs[82].search(r'*') + regexs[82].search(strings[48]) + regexs[82].search(r'.pybfr') + regexs[82].search(strings[82]) + regexs[82].search(strings[83]) + regexs[82].search(strings[84]) + regexs[82].search(strings[86]) + regexs[82].search(r'qg') + regexs[82].search(r'rzorq') + regexs[82].search(r'sbez.nwnk') + regexs[82].search(strings[90]) + regexs[82].search(r'bowrpg') + regexs[83].search(strings[98]) + regexs[83].search(r'shapgvba sbphf() { [angvir pbqr] }') + regexs[62].search(r'#Ybtva') + regexs[62].search(r'#Ybtva_cnffjbeq') + regexs[62].search(strings[77]) + regexs[62].search(r'#fubhgobkWf') + regexs[62].search(r'#fubhgobkWfReebe') + regexs[62].search(r'#fubhgobkWfFhpprff') + regexs[62].search(r'*') + regexs[62].search(strings[82]) + regexs[62].search(strings[83]) + regexs[62].search(strings[86]) + regexs[62].search(r'rzorq') + regexs[62].search(r'sbez.nwnk') + regexs[62].search(strings[90]) + regexs[62].search(r'bowrpg') + regexs[49].search(r'pbagrag') + regexs[24].search(strings[6]) + re.search(r'xbadhrebe', strings[63]) + re.search(r'znp', 'jva32') + re.search(r'zbmvyyn', strings[63]) + re.search(r'zfvr', strings[63]) + re.search(r'ag\s5\.1', strings[63]) + re.search(r'bcren', strings[63]) + re.search(r'fnsnev', strings[63]) + re.search(r'jva', 'jva32') + re.search(r'jvaqbjf', strings[63]) + + +def bench_regex_v8(loops): + for loops in range(loops): + block0() + block1() + block2() + block3() + block4() + block5() + block6() + block7() + block8() + block9() + block10() + block11() + + +def run(): + bench_regex_v8(8) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/scimark.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/scimark.py new file mode 100644 index 0000000000..44a129d1fd --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/scimark.py @@ -0,0 +1,414 @@ +from array import array +import math +import argparse + + +class Array2D(object): + + def __init__(self, w, h, data=None): + self.width = w + self.height = h + self.data = array('d', [0]) * (w * h) + if data is not None: + self.setup(data) + + def _idx(self, x, y): + if 0 <= x < self.width and 0 <= y < self.height: + return y * self.width + x + raise IndexError + + def __getitem__(self, x_y): + (x, y) = x_y + return self.data[self._idx(x, y)] + + def __setitem__(self, x_y, val): + (x, y) = x_y + self.data[self._idx(x, y)] = val + + def setup(self, data): + for y in range(self.height): + for x in range(self.width): + self[x, y] = data[y][x] + return self + + def indexes(self): + for y in range(self.height): + for x in range(self.width): + yield x, y + + def copy_data_from(self, other): + self.data[:] = other.data[:] + + +class Random(object): + MDIG = 32 + ONE = 1 + m1 = (ONE << (MDIG - 2)) + ((ONE << (MDIG - 2)) - ONE) + m2 = ONE << MDIG // 2 + dm1 = 1.0 / float(m1) + + def __init__(self, seed): + self.initialize(seed) + self.left = 0.0 + self.right = 1.0 + self.width = 1.0 + self.haveRange = False + + def initialize(self, seed): + + self.seed = seed + seed = abs(seed) + jseed = min(seed, self.m1) + if (jseed % 2 == 0): + jseed -= 1 + k0 = 9069 % self.m2 + k1 = 9069 / self.m2 + j0 = jseed % self.m2 + j1 = jseed / self.m2 + self.m = array('d', [0]) * 17 + for iloop in range(17): + jseed = j0 * k0 + j1 = (jseed / self.m2 + j0 * k1 + j1 * k0) % (self.m2 / 2) + j0 = jseed % self.m2 + self.m[iloop] = j0 + self.m2 * j1 + self.i = 4 + self.j = 16 + + def nextDouble(self): + I, J, m = self.i, self.j, self.m + k = m[I] - m[J] + if (k < 0): + k += self.m1 + self.m[J] = k + + if (I == 0): + I = 16 + else: + I -= 1 + self.i = I + + if (J == 0): + J = 16 + else: + J -= 1 + self.j = J + + if (self.haveRange): + return self.left + self.dm1 * float(k) * self.width + else: + return self.dm1 * float(k) + + def RandomMatrix(self, a): + for x, y in a.indexes(): + a[x, y] = self.nextDouble() + return a + + def RandomVector(self, n): + return array('d', [self.nextDouble() for i in range(n)]) + + +def copy_vector(vec): + # Copy a vector created by Random.RandomVector() + vec2 = array('d') + vec2[:] = vec[:] + return vec2 + + +class ArrayList(Array2D): + + def __init__(self, w, h, data=None): + self.width = w + self.height = h + self.data = [array('d', [0]) * w for y in range(h)] + if data is not None: + self.setup(data) + + def __getitem__(self, idx): + if isinstance(idx, tuple): + return self.data[idx[1]][idx[0]] + else: + return self.data[idx] + + def __setitem__(self, idx, val): + if isinstance(idx, tuple): + self.data[idx[1]][idx[0]] = val + else: + self.data[idx] = val + + def copy_data_from(self, other): + for l1, l2 in zip(self.data, other.data): + l1[:] = l2 + + +def SOR_execute(omega, G, cycles, Array): + for p in range(cycles): + for y in range(1, G.height - 1): + for x in range(1, G.width - 1): + G[x, y] = (omega * 0.25 * (G[x, y - 1] + G[x, y + 1] + G[x - 1, y] + + G[x + 1, y]) + + (1.0 - omega) * G[x, y]) + + +def bench_SOR(loops, n, cycles, Array): + range_it = range(loops) + + for _ in range_it: + G = Array(n, n) + SOR_execute(1.25, G, cycles, Array) + + +def SparseCompRow_matmult(M, y, val, row, col, x, num_iterations): + range_it = range(num_iterations) + + for _ in range_it: + for r in range(M): + sa = 0.0 + for i in range(row[r], row[r + 1]): + sa += x[col[i]] * val[i] + y[r] = sa + + +def bench_SparseMatMult(cycles, N, nz): + x = array('d', [0]) * N + y = array('d', [0]) * N + + nr = nz // N + anz = nr * N + val = array('d', [0]) * anz + col = array('i', [0]) * nz + row = array('i', [0]) * (N + 1) + + row[0] = 0 + for r in range(N): + rowr = row[r] + step = r // nr + row[r + 1] = rowr + nr + if step < 1: + step = 1 + for i in range(nr): + col[rowr + i] = i * step + + return SparseCompRow_matmult(N, y, val, row, col, x, cycles) + + +def MonteCarlo(Num_samples): + rnd = Random(113) + under_curve = 0 + for count in range(Num_samples): + x = rnd.nextDouble() + y = rnd.nextDouble() + if x * x + y * y <= 1.0: + under_curve += 1 + return float(under_curve) / Num_samples * 4.0 + + +def bench_MonteCarlo(loops, Num_samples): + range_it = range(loops) + + for _ in range_it: + MonteCarlo(Num_samples) + + +def LU_factor(A, pivot): + M, N = A.height, A.width + minMN = min(M, N) + for j in range(minMN): + jp = j + t = abs(A[j][j]) + for i in range(j + 1, M): + ab = abs(A[i][j]) + if ab > t: + jp = i + t = ab + pivot[j] = jp + + if A[jp][j] == 0: + raise Exception("factorization failed because of zero pivot") + + if jp != j: + A[j], A[jp] = A[jp], A[j] + + if j < M - 1: + recp = 1.0 / A[j][j] + for k in range(j + 1, M): + A[k][j] *= recp + + if j < minMN - 1: + for ii in range(j + 1, M): + for jj in range(j + 1, N): + A[ii][jj] -= A[ii][j] * A[j][jj] + + +def LU(lu, A, pivot): + lu.copy_data_from(A) + LU_factor(lu, pivot) + + +def bench_LU(cycles, N): + rnd = Random(7) + A = rnd.RandomMatrix(ArrayList(N, N)) + lu = ArrayList(N, N) + pivot = array('i', [0]) * N + range_it = range(cycles) + + for _ in range_it: + LU(lu, A, pivot) + + +def int_log2(n): + k = 1 + log = 0 + while k < n: + k *= 2 + log += 1 + if n != 1 << log: + raise Exception("FFT: Data length is not a power of 2: %s" % n) + return log + + +def FFT_num_flops(N): + return (5.0 * N - 2) * int_log2(N) + 2 * (N + 1) + + +def FFT_transform_internal(N, data, direction): + n = N // 2 + bit = 0 + dual = 1 + if n == 1: + return + + logn = int_log2(n) + if N == 0: + return + FFT_bitreverse(N, data) + + # apply fft recursion + # this loop executed int_log2(N) times + bit = 0 + while bit < logn: + w_real = 1.0 + w_imag = 0.0 + theta = 2.0 * direction * math.pi / (2.0 * float(dual)) + s = math.sin(theta) + t = math.sin(theta / 2.0) + s2 = 2.0 * t * t + for b in range(0, n, 2 * dual): + i = 2 * b + j = 2 * (b + dual) + wd_real = data[j] + wd_imag = data[j + 1] + data[j] = data[i] - wd_real + data[j + 1] = data[i + 1] - wd_imag + data[i] += wd_real + data[i + 1] += wd_imag + for a in range(1, dual): + tmp_real = w_real - s * w_imag - s2 * w_real + tmp_imag = w_imag + s * w_real - s2 * w_imag + w_real = tmp_real + w_imag = tmp_imag + for b in range(0, n, 2 * dual): + i = 2 * (b + a) + j = 2 * (b + a + dual) + z1_real = data[j] + z1_imag = data[j + 1] + wd_real = w_real * z1_real - w_imag * z1_imag + wd_imag = w_real * z1_imag + w_imag * z1_real + data[j] = data[i] - wd_real + data[j + 1] = data[i + 1] - wd_imag + data[i] += wd_real + data[i + 1] += wd_imag + bit += 1 + dual *= 2 + + +def FFT_bitreverse(N, data): + n = N // 2 + nm1 = n - 1 + j = 0 + for i in range(nm1): + ii = i << 1 + jj = j << 1 + k = n >> 1 + if i < j: + tmp_real = data[ii] + tmp_imag = data[ii + 1] + data[ii] = data[jj] + data[ii + 1] = data[jj + 1] + data[jj] = tmp_real + data[jj + 1] = tmp_imag + while k <= j: + j -= k + k >>= 1 + j += k + + +def FFT_transform(N, data): + FFT_transform_internal(N, data, -1) + + +def FFT_inverse(N, data): + n = N / 2 + norm = 0.0 + FFT_transform_internal(N, data, +1) + norm = 1 / float(n) + for i in range(N): + data[i] *= norm + + +def bench_FFT(loops, N, cycles): + twoN = 2 * N + init_vec = Random(7).RandomVector(twoN) + range_it = range(loops) + + for _ in range_it: + x = copy_vector(init_vec) + for i in range(cycles): + FFT_transform(twoN, x) + FFT_inverse(twoN, x) + + +def add_cmdline_args(cmd, args): + if args.benchmark: + cmd.append(args.benchmark) + + +BENCHMARKS = { + # function name => arguments + 'sor': (bench_SOR, 1, 100, 1, Array2D), + 'sparse_mat_mult': (bench_SparseMatMult, 4, 1000, 50 * 1000), + 'monte_carlo': (bench_MonteCarlo, 2, 10 * 1000,), + 'lu': (bench_LU, 1, 50,), + 'fft': (bench_FFT, 1, 1024, 5), +} + + +def run(): + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("benchmark", nargs='?', + choices=sorted(BENCHMARKS)) + + args = parser.parse_args() + if args.benchmark: + benchmarks = (args.benchmark,) + else: + benchmarks = sorted(BENCHMARKS) + + for bench in benchmarks: + func, *func_args = BENCHMARKS[bench] + func(*func_args) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/spectral_norm.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/spectral_norm.py new file mode 100644 index 0000000000..63cad9f280 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/spectral_norm.py @@ -0,0 +1,81 @@ +""" +MathWorld: "Hundred-Dollar, Hundred-Digit Challenge Problems", Challenge #3. +http://mathworld.wolfram.com/Hundred-DollarHundred-DigitChallengeProblems.html + +The Computer Language Benchmarks Game +http://benchmarksgame.alioth.debian.org/u64q/spectralnorm-description.html#spectralnorm + +Contributed by Sebastien Loisel +Fixed by Isaac Gouy +Sped up by Josh Goldfoot +Dirtily sped up by Simon Descarpentries +Concurrency by Jason Stitt +""" + + +DEFAULT_N = 130 + + +def eval_A(i, j): + return 1.0 / ((i + j) * (i + j + 1) // 2 + i + 1) + + +def eval_times_u(func, u): + return [func((i, u)) for i in range(len(list(u)))] + + +def eval_AtA_times_u(u): + return eval_times_u(part_At_times_u, eval_times_u(part_A_times_u, u)) + + +def part_A_times_u(i_u): + i, u = i_u + partial_sum = 0 + for j, u_j in enumerate(u): + partial_sum += eval_A(i, j) * u_j + return partial_sum + + +def part_At_times_u(i_u): + i, u = i_u + partial_sum = 0 + for j, u_j in enumerate(u): + partial_sum += eval_A(j, i) * u_j + return partial_sum + + +def bench_spectral_norm(loops): + range_it = range(loops) + + for _ in range_it: + u = [1] * DEFAULT_N + + for dummy in range(10): + v = eval_AtA_times_u(u) + u = eval_AtA_times_u(v) + + vBv = vv = 0 + + for ue, ve in zip(u, v): + vBv += ue * ve + vv += ve * ve + + +def run(): + bench_spectral_norm(1) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/telco.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/telco.py new file mode 100644 index 0000000000..fefc0a81ae --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/telco.py @@ -0,0 +1,101 @@ +# coding: UTF-8 +""" Telco Benchmark for measuring the performance of decimal calculations + +- http://speleotrove.com/decimal/telco.html +- http://speleotrove.com/decimal/telcoSpec.html + +A call type indicator, c, is set from the bottom (least significant) bit of the duration (hence c is 0 or 1). +A rate, r, is determined from the call type. Those calls with c=0 have a low r: 0.0013; the remainder (‘distance calls’) have a ‘premium’ r: 0.00894. (The rates are, very roughly, in Euros or dollarates per second.) +A price, p, for the call is then calculated (p=r*n). This is rounded to exactly 2 fractional digits using round-half-even (Banker’s round to nearest). +A basic tax, b, is calculated: b=p*0.0675 (6.75%). This is truncated to exactly 2 fractional digits (round-down), and the total basic tax variable is then incremented (sumB=sumB+b). +For distance calls: a distance tax, d, is calculated: d=p*0.0341 (3.41%). This is truncated to exactly 2 fractional digits (round-down), and then the total distance tax variable is incremented (sumD=sumD+d). +The total price, t, is calculated (t=p+b, and, if a distance call, t=t+d). +The total prices variable is incremented (sumT=sumT+t). +The total price, t, is converted to a string, s. + +""" + +from decimal import ROUND_HALF_EVEN, ROUND_DOWN, Decimal, getcontext, Context +import io +import os +from struct import unpack + + +def rel_path(*path): + return os.path.join(os.path.dirname(__file__), *path) + + +def bench_telco(loops, filename): + getcontext().rounding = ROUND_DOWN + rates = list(map(Decimal, ('0.0013', '0.00894'))) + twodig = Decimal('0.01') + Banker = Context(rounding=ROUND_HALF_EVEN) + basictax = Decimal("0.0675") + disttax = Decimal("0.0341") + + with open(filename, "rb") as infil: + data = infil.read() + + infil = io.BytesIO(data) + outfil = io.StringIO() + + for _ in range(loops): + infil.seek(0) + + sumT = Decimal("0") # sum of total prices + sumB = Decimal("0") # sum of basic tax + sumD = Decimal("0") # sum of 'distance' tax + + for i in range(5000): + datum = infil.read(8) + if datum == '': + break + n, = unpack('>Q', datum) + + calltype = n & 1 + r = rates[calltype] + + p = Banker.quantize(r * n, twodig) + + b = p * basictax + b = b.quantize(twodig) + sumB += b + + t = p + b + + if calltype: + d = p * disttax + d = d.quantize(twodig) + sumD += d + t += d + + sumT += t + print(t, file=outfil) + + outfil.seek(0) + outfil.truncate() + + +def run(): + filename = rel_path("data", "telco-bench.b") + bench_telco(1, filename) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["data/telco-bench.b"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpack_sequence.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpack_sequence.py new file mode 100644 index 0000000000..eae9d95223 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpack_sequence.py @@ -0,0 +1,466 @@ +"""Microbenchmark for Python's sequence unpacking.""" + +import argparse + + +def do_unpacking(loops, to_unpack): + range_it = range(loops) + + for _ in range_it: + # 400 unpackings + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + a, b, c, d, e, f, g, h, i, j = to_unpack + + +def bench_tuple_unpacking(loops): + x = tuple(range(10)) + do_unpacking(loops, x) + + +def bench_list_unpacking(loops): + x = list(range(10)) + + do_unpacking(loops, x) + + +def bench_all(loops): + bench_tuple_unpacking(loops) + bench_list_unpacking(loops) + + +def add_cmdline_args(cmd, args): + if args.benchmark: + cmd.append(args.benchmark) + + +def run(): + benchmarks = {"tuple": bench_tuple_unpacking, + "list": bench_list_unpacking} + + parser = argparse.ArgumentParser(prog="python") + parser.add_argument("benchmark", nargs="?", + choices=sorted(benchmarks)) + + options = parser.parse_args() + name = 'unpack_sequence' + if options.benchmark: + func = benchmarks[options.benchmark] + name += "_%s" % options.benchmark + else: + func = bench_all + + func(8192) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle.py new file mode 100644 index 0000000000..18bc21a969 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle.py @@ -0,0 +1,28 @@ +import sys +import os +# Add benchmark directory to path to allow import of bm_pickle.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import bm_pickle + +def run(): + bm_pickle.__benchmark__(["unpickle"]) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["bm_pickle.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle_list.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle_list.py new file mode 100644 index 0000000000..c155a5282c --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/pyperformance/unpickle_list.py @@ -0,0 +1,28 @@ +import sys +import os +# Add benchmark directory to path to allow import of bm_pickle.py +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) +import bm_pickle + +def run(): + bm_pickle.__benchmark__(["unpickle_list"]) + + +def warmupIterations(): + return 0 + + +def iterations(): + return 10 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } + + +def dependencies(): + return ["bm_pickle.py"] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup-imports.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup-imports.py new file mode 100644 index 0000000000..158e9ed895 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup-imports.py @@ -0,0 +1,56 @@ +# Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +import os +import subprocess +import sys +import fast_subprocess + +def __setup__(*args): + fast_subprocess.setup() + + +def __teardown__(): + fast_subprocess.teardown() + + +def __benchmark__(num=1000000): + fast_subprocess.run(num, "import threading;import contextlib;import contextvars;import decimal;" + "import ast;import asyncio;import argparse;import base64;import bisect;import calendar;" + "import configparser;import copyreg;import dataclasses;import enum;import fractions;" + "import glob;import hashlib;import os;import typing;import tomllib") diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup.py new file mode 100644 index 0000000000..18352db9bd --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/startup.py @@ -0,0 +1,53 @@ +# Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +import os +import subprocess +import sys +import fast_subprocess + +def __setup__(*args): + fast_subprocess.setup() + + +def __teardown__(): + fast_subprocess.teardown() + + +def __benchmark__(num=1000000): + fast_subprocess.run(num, "1") diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.py b/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.py index 0e0cc41342..ae972f4ed6 100644 --- a/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.py +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.py @@ -1,4 +1,4 @@ -# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -43,26 +43,15 @@ import os -PYC_BYTES = [] - - -def initialize_pyc_bytes(): - dirname = os.path.dirname(__file__) - for filename in os.listdir(dirname): - if filename.endswith(".py"): - filepath = os.path.join(dirname, filename) - with io.open_code(filepath) as f: - PYC_BYTES.append(marshal.dumps(compile(f.read(), filename, "exec"))) - - -initialize_pyc_bytes() -del initialize_pyc_bytes +with io.open_code(os.path.join(os.path.dirname(__file__), "unmarshal-pyc.txt")) as f: + PYC_BYTES = marshal.dumps(compile(f.read() * 1000, "pyc", "exec")) def measure(inner_iterations=1): - for _ in range(inner_iterations): - for pyc_bytes in PYC_BYTES: - marshal.loads(pyc_bytes) + pyc_bytes = PYC_BYTES + while inner_iterations > 0: + marshal.loads(pyc_bytes) + inner_iterations -= 1 def __benchmark__(inner_iterations=1): diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.txt b/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.txt new file mode 100644 index 0000000000..e97ec8ffd6 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/micro/unmarshal-pyc.txt @@ -0,0 +1,529 @@ +# Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +import math +import time + +""" + * @file ex_particle_OPENMP_seq.c + * @author Michael Trotter & Matt Goodrum + * @brief Particle filter implementation in C/OpenMP + """ + +PI = 3.1415926535897932 + +""" +@var M value for Linear Congruential Generator (LCG) use GCC's value +""" +M = 2147483647 +""" +@var A value for LCG +""" +A = 1103515245 +""" +@var C value for LCG +""" +C = 12345 + +""" +* Set values of the 3D array to a newValue if that value is equal to the testValue +* @param testValue The value to be replaced +* @param newValue The value to replace testValue with +* @param array3D The image vector +* @param dimX The x dimension of the frame +* @param dimY The y dimension of the frame +* @param dimZ The number of frames +""" + + +def setIf(testValue, newValue, array3D, dimX, dimY, dimZ): + for x in range(dimX): + for y in range(dimY): + for z in range(dimZ): + if (array3D[x*dimZ*dimY + y*dimZ + z] == testValue): + array3D[x*dimZ*dimY + y*dimZ + z] = newValue + + +# emulate c++ int overflow +def cppNum(num): + return (num + 2**31) % 2**32 - 2**31 + + +def cppMod(num, x): + return num % x if num > 0 else -1 * ((-1 * num) % x) + + +""" +* Generates a uniformly distributed random number using the provided seed and GCC's settings for the Linear Congruential Generator (LCG) +* @see http:#en.wikipedia.org/wiki/Linear_congruential_generator +* @note This function is thread-safe +* @param seed The seed array +* @param index The specific index of the seed to be advanced +* @return a uniformly distributed number [0, 1) +""" + + +def randu(seed, index): + """uniformly distributed random number""" + num = cppNum(A * seed[index] + C) + seed[index] = cppMod(num, M) + # seed[index] = num % M + return math.fabs(seed[index] / (float(M))) + + +def randn(seed, index): + """Box-Muller algorithm""" + u = randu(seed, index) + v = randu(seed, index) + cosine = math.cos(2 * PI * v) + rt = -2 * math.log(u) + + return math.sqrt(rt) * cosine + +# def randu(seed, index): +# num = A * seed[index] + C +# seed[index] = num % M +# return math.fabs(seed[index] / (float(M))) +# +# """ +# * Generates a normally distributed random number using the Box-Muller transformation +# * @note This function is thread-safe +# * @param seed The seed array +# * @param index The specific index of the seed to be advanced +# * @return a double representing random number generated using the Box-Muller algorithm +# * @see http:#en.wikipedia.org/wiki/Normal_distribution, section computing value for normal random distribution +# """ +# +# +# def randn(seed, index): +# """Box-Muller algorithm""" +# u = randu(seed, index) +# v = randu(seed, index) +# cosine = math.cos(2 * PI * v) +# rt = -2 * math.log(u) +# return math.sqrt(rt) * cosine +# +# """ +# * Sets values of 3D matrix using randomly generated numbers from a normal distribution +# * @param array3D The video to be modified +# * @param dimX The x dimension of the frame +# * @param dimY The y dimension of the frame +# * @param dimZ The number of frames +# * @param seed The seed array +# """ + + +def addNoise(array3D, dimX, dimY, dimZ, randn_noise): + for x in range(dimX): + for y in range(dimY): + for z in range(dimZ): + array3D[x*dimZ*dimY + y*dimZ + z] = array3D[x*dimZ*dimY + y * + dimZ + z] + int((5 * randn_noise[x*dimZ*dimY + y*dimZ + z])) + + +""" +* Dilates the provided video +* @param matrix The video to be dilated +* @param posX The x location of the pixel to be dilated +* @param posY The y location of the pixel to be dilated +* @param poxZ The z location of the pixel to be dilated +* @param dimX The x dimension of the frame +* @param dimY The y dimension of the frame +* @param dimZ The number of frames +* @param error The error radius +""" + + +def dilate_matrix(newMatrix, posX, posY, posZ, dimX, dimY, dimZ, error): + startX = posX - error + while (startX < 0): + startX += 1 + startY = posY - error + while (startY < 0): + startY += 1 + endX = posX + error + while (endX > dimX): + endX -= 1 + endY = posY + error + while (endY > dimY): + endY -= 1 + for x in range(startX, endX): + for y in range(startY, endY): + distance = math.sqrt(float(x - posX) ** 2 + + float(y - posY) ** 2) + if(distance < error): + newMatrix[x*dimZ*dimY + y*dimZ + posZ] = 1 + + +""" +* Dilates the target matrix using the radius as a guide +* @param matrix The reference matrix +* @param dimX The x dimension of the video +* @param dimY The y dimension of the video +* @param dimZ The z dimension of the video +* @param error The error radius to be dilated +* @param newMatrix The target matrix +""" + + +def imdilate_disk(matrix, dimX, dimY, dimZ, error, newMatrix): + for posX in range(dimX): + for posY in range(dimY): + for posZ in range(dimZ): + if(matrix[posX*dimZ*dimY + posY*dimZ + posZ] == 1): + # dilate_matrix(newMatrix, posX, posY, posZ, dimX, dimY, dimZ, error) + startX = posX - error + while (startX < 0): + startX += 1 + startY = posY - error + while (startY < 0): + startY += 1 + endX = posX + error + while (endX > dimX): + endX -= 1 + endY = posY + error + while (endY > dimY): + endY -= 1 + for x in range(startX, endX): + for y in range(startY, endY): + distance = math.sqrt(float(x - posX) ** 2 + + float(y - posY) ** 2) + if(distance < error): + newMatrix[x*dimZ*dimY + y*dimZ + posZ] = 1 + + +""" +* The synthetic video sequence we will work with here is composed of a +* single moving object, circular in shape (fixed radius) +* The motion here is a linear motion +* the foreground intensity and the backgrounf intensity is known +* the image is corrupted with zero mean Gaussian noise +* @param I The video itself +* @param IszX The x dimension of the video +* @param IszY The y dimension of the video +* @param Nfr The number of frames of the video +* @param seed The seed array used for number generation +""" + + +def copyMatrix(I, newMatrix, IszX, IszY, Nfr): + for x in range(IszX): + for y in range(IszY): + for z in range(Nfr): + I[x*Nfr*IszY + y*Nfr + z] = newMatrix[x*Nfr*IszY + y*Nfr + z] + + +def videoSequence(I, IszX, IszY, Nfr, newMatrix, randn_noise): + max_size = IszX * IszY * Nfr + """get object centers""" + x0 = int(round(IszY / 2.0)) + y0 = int(round(IszX / 2.0)) + I[x0*Nfr*IszY + y0*Nfr + 0] = 1 + + """move point""" + for k in range(1, Nfr): + xk = int(abs(x0 + (k - 1))) + yk = int(abs(y0 - 2 * (k - 1))) + pos = yk * IszY * Nfr + xk * Nfr + k + if(pos >= max_size): + pos = 0 + I[yk*Nfr*IszY + xk*Nfr + k] = 1 + + """dilate matrix""" + imdilate_disk(I, IszX, IszY, Nfr, 5, newMatrix) + # copyMatrix(I, newMatrix, IszX, IszY, Nfr) + + """define background, add noise""" + # setIf(0, 100, I, IszX, IszY, Nfr) + # setIf(1, 228, I, IszX, IszY, Nfr) + + """add noise""" + # addNoise(I, IszX, IszY, Nfr, randn_noise) + for x in range(IszX): + for y in range(IszY): + for z in range(Nfr): + I[x*Nfr*IszY + y*Nfr + z] = newMatrix[x*Nfr*IszY + y*Nfr + z] + if (I[x*Nfr*IszY + y*Nfr + z] == 0): + I[x*Nfr*IszY + y*Nfr + z] = 100 + if (I[x*Nfr*IszY + y*Nfr + z] == 1): + I[x*Nfr*IszY + y*Nfr + z] = 228 + + I[x*Nfr*IszY + y*Nfr + z] = \ + I[x*Nfr*IszY + y*Nfr + z] +\ + int((5 * randn_noise[x*Nfr*IszY + y*Nfr + z])) + + +""" +* Finds the first element in the CDF that is greater than or equal to the provided value and returns that index +* @note This function uses sequential search +* @param CDF The CDF +* @param lengthCDF The length of CDF +* @param value The value to be found +* @return The index of value in the CDF if value is never found, returns the last index +""" + + +def findIndex(CDF, lengthCDF, value): + index = -1 + for x in range(lengthCDF): + if CDF[x] >= value: + index = x + break + + if index == -1: + return lengthCDF - 1 + + return index + + +""" +* Finds the first element in the CDF that is greater than or equal to the provided value and returns that index +* @note This function uses binary search before switching to sequential search +* @param CDF The CDF +* @param beginIndex The index to start searching from +* @param endIndex The index to stop searching +* @param value The value to find +* @return The index of value in the CDF if value is never found, returns the last index +* @warning Use at your own risk not fully tested +""" + + +def findIndexBin(CDF, beginIndex, endIndex, value): + if(endIndex < beginIndex): + return -1 + middleIndex = beginIndex + ((endIndex - beginIndex) / 2) + """check the value""" + if CDF[middleIndex] >= value: + """check that it's good""" + if middleIndex == 0: + return middleIndex + elif CDF[middleIndex - 1] < value: + return middleIndex + elif CDF[middleIndex - 1] == value: + while middleIndex > 0 and CDF[middleIndex - 1] == value: + middleIndex -= 1 + return middleIndex + + if CDF[middleIndex] > value: + return findIndexBin(CDF, beginIndex, middleIndex + 1, value) + + return findIndexBin(CDF, middleIndex - 1, endIndex, value) + + +""" +* @note This function is designed to work with a video of several frames. + In addition, it references a provided MATLAB function which takes + the video, the objxy matrix and the x and y arrays as arguments and + returns the likelihoods +* @param I The video to be run +* @param IszX The x dimension of the video +* @param IszY The y dimension of the video +* @param Nfr The number of frames +* @param seed The seed array used for random number generation +* @param Nparticles The number of particles to be used +""" + + +def particleFilter(I, IszX, IszY, Nfr, Nparticles, arrayX, arrayY, randn_X, randn_Y, weights, CDF, frames_randu, xj, yj): + max_size = IszX * IszY * Nfr + # original particle centroid + xe1 = round(IszY / 2.0) + ye1 = round(IszX / 2.0) + + # expected object locations, compared to center + radius = 5 + diameter = radius * 2 - 1 + center = radius - 1 + + for x in range(Nparticles): + weights[x] = 1 / (float(Nparticles)) + arrayX[x] = xe1 * 1. + arrayY[x] = ye1 * 1. + + for k in range(1, Nfr): + # apply motion model + # draws sample from motion model (random walk). The only prior information + # is that the object moves 2x as fast as in the y direction + + for x in range(Nparticles): + arrayX[x] += 1 + 5 * randn_X[x] + arrayY[x] += -2 + 2 * randn_Y[x] + + likelihood = 0. + countOnes = 0 + www = 0 + + for xx in range(diameter): + for yy in range(diameter): + distance = math.sqrt( + (float((xx - radius + 1)) ** 2) + (float(yy - radius + 1) ** 2)) + if (distance < radius): + countOnes += 1 + indXXX = round(arrayX[x]) + (xx - center) + indXX = abs(indXXX) + indYYY = round(arrayY[x]) + (yy - center) + indYY = abs(indYYY) + indX = int(indXX) + indY = int(indYY) + indZ = k + if(indX >= IszX or indY >= IszY): + indX = 0 + indY = 0 + indZ = 0 + + likelihood += ((I[indX*Nfr*IszY + indY*Nfr + indZ] - 100) ** 2 - + (I[indX*Nfr*IszY + indY*Nfr + indZ] - 228) ** 2) / 50.0 + + likelihood = likelihood / (float(countOnes)) + # update & normalize weights + # using equation (63) of Arulampalam Tutorial + weights[x] = weights[x] * math.exp(likelihood) + + sumWeights = 0. + for x in range(Nparticles): + sumWeights += weights[x] + + for x in range(Nparticles): + weights[x] = weights[x] / sumWeights + + xe = 0. + ye = 0. + # estimate the object location by expected values + for x in range(Nparticles): + xe += arrayX[x] * weights[x] + ye += arrayY[x] * weights[x] + + distance = math.sqrt(float(xe - int(round(IszY / 2.0))) + ** 2 + float(ye - int(round(IszX / 2.0))) ** 2) + + # resampling + CDF[0] = weights[0] + for x in range(1, Nparticles): + CDF[x] = weights[x] + CDF[x - 1] + u1 = (1 / (float(Nparticles))) * frames_randu[k] + + for x in range(Nparticles): + v = u1 + x / (float(Nparticles)) + i = findIndex(CDF, Nparticles, v) + + xj[x] = arrayX[i] + yj[x] = arrayY[i] + + for x in range(Nparticles): + # reassign arrayX and arrayY + arrayX[x] = xj[x] + arrayY[x] = yj[x] + weights[x] = 1 / (float(Nparticles)) + + +class Data: + def __init__(self): + self.I = None + self.newMatrix = None + self.weights = None + self.likelihood = None + self.arrayX = None + self.arrayY = None + self.xj = None + self.yj = None + self.CDF = None + self.u = None + + self.randn_X = None + self.randn_Y = None + self.randn_noise = None + self.frames_randu = None + + +data = Data() + +default_size1 = 1024 +default_size2 = 96 +default_size3 = 16 + + +def measure(Nparticles=default_size1, IszX=default_size2, IszY=default_size2, Nfr=default_size3): + # call video sequence + videoSequence(data.I, IszX, IszY, Nfr, data.newMatrix, data.randn_noise) + # call particle filter + particleFilter(data.I, IszX, IszY, Nfr, Nparticles, data.arrayX, data.arrayY, + data.randn_X, data.randn_Y, data.weights, data.CDF, data.frames_randu, data.xj, data.yj) + + +def __benchmark__(Nparticles=10): + measure(Nparticles) + + +def __setup__(Nparticles=default_size1, IszX=default_size2, IszY=default_size2, Nfr=default_size3): + data.I = [0 for i in range(Nfr*IszY*IszX)] + data.newMatrix = [0 for i in range(Nfr*IszY*IszX)] + # initial weights are all equal (1/Nparticles) + data.weights = [0. for i in range(Nparticles)] + # initial likelihood to 0.0 + data.likelihood = [0. for i in range(Nparticles)] + data.arrayX = [0. for i in range(Nparticles)] + data.arrayY = [0. for i in range(Nparticles)] + data.xj = [0. for i in range(Nparticles)] + data.yj = [0. for i in range(Nparticles)] + data.CDF = [0. for i in range(Nparticles)] + data.u = [0. for i in range(Nparticles)] + # establish seed + seed = [int(time.time() % M + 1) * i for i in range(Nparticles)] + + data.randn_X = [randn(seed, i) for i in range(Nparticles)] + data.randn_Y = [randn(seed, i) for i in range(Nparticles)] + data.randn_noise = [randn(seed, 0) for i in range(Nfr*IszY*IszX)] + data.frames_randu = [randn(seed, 0) for i in range(Nfr)] + + +def __cleanup__(Nparticles=default_size1, IszX=default_size2, IszY=default_size2, Nfr=default_size3): + # clean up written data + for i in range(Nfr*IszY*IszX): + data.I[i] = 0 + data.newMatrix[i] = 0 + for i in range(Nparticles): + data.weights[i] = 0. + data.likelihood[i] = 0. + data.arrayX[i] = 0. + data.arrayY[i] = 0. + data.xj[i] = 0. + data.yj[i] = 0. + data.CDF[i] = 0. + data.u[i] = 0. diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/OWNERS.toml b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/OWNERS.toml new file mode 100644 index 0000000000..34cb11f338 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/OWNERS.toml @@ -0,0 +1,6 @@ +[[rule]] +files = "*" +any = [ + "francois.farquet@oracle.com", + "andrija.kolic@oracle.com", +] diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/complex_stdlib_import.py b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/complex_stdlib_import.py new file mode 100644 index 0000000000..11e79a3a40 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/complex_stdlib_import.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Benchmark a more complex standard library import. +""" + + +def run(): + import urllib.request + + +# Warmup benchmarks, by definition, are just a single iteration that we measure end-to-end. +# Thus, the following values are fixed and are not tunable. +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/matplotlib_import.py b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/matplotlib_import.py new file mode 100644 index 0000000000..8c540150fe --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/matplotlib_import.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Benchmark a more complex third-party import. +""" + + +def run(): + import matplotlib + print(f"Imported {matplotlib.__name__} version '{matplotlib.__version__}'") + + +# Warmup benchmarks, by definition, are just a single iteration that we measure end-to-end. +# Thus, the following values are fixed and are not tunable. +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/simple_stdlib_import.py b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/simple_stdlib_import.py new file mode 100644 index 0000000000..9189f8e023 --- /dev/null +++ b/graalpython/com.oracle.graal.python.benchmarks/python/warmup/import/simple_stdlib_import.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +""" +Benchmark a simple standard library import. +""" + + +def run(): + import email.utils + + +# Warmup benchmarks, by definition, are just a single iteration that we measure end-to-end. +# Thus, the following values are fixed and are not tunable. +def warmupIterations(): + return 0 + + +def iterations(): + return 1 + + +def summary(): + return { + "name": "OutlierRemovalAverageSummary", + "lower-threshold": 0.0, + "upper-threshold": 1.0, + } diff --git a/graalpython/com.oracle.graal.python.bouncycastle/pom.xml b/graalpython/com.oracle.graal.python.bouncycastle/pom.xml new file mode 100644 index 0000000000..5db5641801 --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/pom.xml @@ -0,0 +1,79 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.bouncycastle + jar + + + + ${project.groupId} + com.oracle.graal.python + + + org.graalvm.sdk + nativeimage + + + org.bouncycastle + bcprov-jdk18on + + + org.bouncycastle + bcpkix-jdk18on + + + org.bouncycastle + bcutil-jdk18on + + + diff --git a/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/native-image.properties b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/native-image.properties new file mode 100644 index 0000000000..13a0ad90d1 --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/native-image.properties @@ -0,0 +1,2 @@ +# Additional native-image arguments for optional GraalPy BouncyCastle support +Args = --features=com.oracle.graal.python.bouncycastle.BouncyCastleFeature diff --git a/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/reflect-config.json b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/reflect-config.json new file mode 100644 index 0000000000..fb104aeb8d --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/native-image/org.graalvm.python/python-bouncycastle/reflect-config.json @@ -0,0 +1,2066 @@ +[ + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.COMPOSITE$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.CompositeSignatures$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.DH$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.DSA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.DSTU4145$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.Dilithium$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.EC$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.ECGOST$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.EXTERNAL$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.EdEC$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.ElGamal$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.Falcon$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.GM$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.GOST$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.IES$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.LMS$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.NTRU$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.RSA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.SPHINCSPlus$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.X509$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.KeyFactorySpi$ECDSA", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.ec.SignatureSpi$ecDSA256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.dsa.KeyFactorySpi", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.asymmetric.rsa.KeyFactorySpi", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2b$Blake2b160", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2b$Blake2b256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2b$Blake2b384", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2b$Blake2b512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2b$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2s$Blake2s128", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2s$Blake2s160", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2s$Blake2s224", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2s$Blake2s256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake2s$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake3$Blake3_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Blake3$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.DSTU7564$Digest256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.DSTU7564$Digest384", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.DSTU7564$Digest512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.DSTU7564$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.GOST3411$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.GOST3411$Digest2012_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.GOST3411$Digest2012_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.GOST3411$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Haraka$Digest256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Haraka$Digest512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Haraka$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Digest224", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Digest256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Digest288", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Digest384", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Digest512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Keccak$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.MD2$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.MD4$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.MD4$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.MD5$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD128$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD128$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD160$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD160$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD256$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD256$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD320$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.RIPEMD320$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA1$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA224$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA256$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestParallelHash128_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestParallelHash256_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestShake128_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestShake256_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestTupleHash128_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$DigestTupleHash256_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA3$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA384$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SHA512$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SM3$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.SM3$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_1024_1024", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_1024_384", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_1024_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_256_128", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_256_160", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_256_224", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_256_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_128", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_160", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_224", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_384", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Digest_512_512", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Skein$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Tiger$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Tiger$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Whirlpool$Digest", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.digest.Whirlpool$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.drbg.DRBG$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.keystore.BC$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.keystore.BCFKS$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.keystore.PKCS12$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$AlgParams", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$ECB", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$CBC", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$CBC128", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$CBC192", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$CBC256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$PBEWithMD5And256BitAESCBCOpenSSL", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.AES$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.ARC4$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.ARIA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Blowfish$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.CAST5$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.CAST6$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Camellia$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.ChaCha$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.DES$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.DESede$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.DSTU7624$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.GOST28147$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.GOST3412_2015$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Grain128$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Grainv1$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.HC128$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.HC256$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.IDEA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Noekeon$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.OpenSSLPBKDF$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF1$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF2$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPBKDF2$PBKDF2withSHA256", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.PBEPKCS12$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Poly1305$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.RC2$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.RC5$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.RC6$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Rijndael$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.SCRYPT$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.SEED$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.SM4$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Salsa20$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Serpent$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Shacal2$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.SipHash$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.SipHash128$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Skipjack$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.TEA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.TLSKDF$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Threefish$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Twofish$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.VMPC$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.VMPCKSA3$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.XSalsa20$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.XTEA$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.jcajce.provider.symmetric.Zuc$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.BIKE$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.CMCE$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Dilithium$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Falcon$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Frodo$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.HQC$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Kyber$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.LMS$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.NH$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.NTRU$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.NTRUPrime$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Picnic$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.Rainbow$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.SABER$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.SPHINCS$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.SPHINCSPlus$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + }, + { + "name": "org.bouncycastle.pqc.jcajce.provider.XMSS$Mappings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ], + "condition": { + "typeReachable": "org.bouncycastle.jce.provider.BouncyCastleProvider" + } + } +] diff --git a/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/services/com.oracle.graal.python.runtime.crypto.BouncyCastleSupport b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/services/com.oracle.graal.python.runtime.crypto.BouncyCastleSupport new file mode 100644 index 0000000000..7bfca52a3e --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/src/META-INF/services/com.oracle.graal.python.runtime.crypto.BouncyCastleSupport @@ -0,0 +1 @@ +com.oracle.graal.python.bouncycastle.BouncyCastleSupportImpl diff --git a/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleFeature.java b/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleFeature.java new file mode 100644 index 0000000000..eeba6d3295 --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleFeature.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.bouncycastle; + +import java.security.Security; + +import org.bouncycastle.jce.provider.BouncyCastleProvider; +import org.graalvm.nativeimage.hosted.Feature; +import org.graalvm.nativeimage.hosted.RuntimeClassInitialization; + +public final class BouncyCastleFeature implements Feature { + @Override + public void afterRegistration(AfterRegistrationAccess access) { + RuntimeClassInitialization.initializeAtBuildTime("org.bouncycastle"); + RuntimeClassInitialization.initializeAtRunTime("org.bouncycastle.jcajce.provider.drbg.DRBG$Default"); + RuntimeClassInitialization.initializeAtRunTime("org.bouncycastle.jcajce.provider.drbg.DRBG$NonceAndIV"); + if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) { + Security.addProvider(new BouncyCastleProvider()); + } + } +} diff --git a/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleSupportImpl.java b/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleSupportImpl.java new file mode 100644 index 0000000000..3c5ad556fa --- /dev/null +++ b/graalpython/com.oracle.graal.python.bouncycastle/src/com/oracle/graal/python/bouncycastle/BouncyCastleSupportImpl.java @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.bouncycastle; + +import java.io.IOException; +import java.io.StringReader; +import java.security.GeneralSecurityException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.PrivateKey; +import java.security.Provider; +import java.security.Security; +import java.security.Signature; + +import org.bouncycastle.asn1.pkcs.PrivateKeyInfo; +import org.bouncycastle.jce.provider.BouncyCastleProvider; +import org.bouncycastle.openssl.PEMEncryptedKeyPair; +import org.bouncycastle.openssl.PEMKeyPair; +import org.bouncycastle.openssl.PEMParser; +import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter; +import org.bouncycastle.openssl.jcajce.JceOpenSSLPKCS8DecryptorProviderBuilder; +import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder; +import org.bouncycastle.operator.OperatorCreationException; +import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo; +import org.bouncycastle.pkcs.PKCSException; + +import com.oracle.graal.python.builtins.objects.ssl.CertUtils.NeedsPasswordException; +import com.oracle.graal.python.runtime.crypto.BouncyCastleSupport; + +public final class BouncyCastleSupportImpl implements BouncyCastleSupport { + private static Provider getProvider() { + Provider provider = Security.getProvider(BouncyCastleProvider.PROVIDER_NAME); + if (provider != null) { + return provider; + } + return new BouncyCastleProvider(); + } + + @Override + public PrivateKey loadPrivateKey(char[] password, String pemText) throws IOException, NeedsPasswordException, GeneralSecurityException { + Provider provider = getProvider(); + try (PEMParser pemParser = new PEMParser(new StringReader(pemText))) { + JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider(provider); + Object object; + while ((object = pemParser.readObject()) != null) { + PrivateKeyInfo pkInfo; + if (object instanceof PEMKeyPair) { + pkInfo = ((PEMKeyPair) object).getPrivateKeyInfo(); + } else if (object instanceof PEMEncryptedKeyPair) { + if (password == null) { + throw new NeedsPasswordException(); + } + JcePEMDecryptorProviderBuilder decryptor = new JcePEMDecryptorProviderBuilder().setProvider(provider); + PEMKeyPair keyPair = ((PEMEncryptedKeyPair) object).decryptKeyPair(decryptor.build(password)); + pkInfo = keyPair.getPrivateKeyInfo(); + } else if (object instanceof PKCS8EncryptedPrivateKeyInfo) { + if (password == null) { + throw new NeedsPasswordException(); + } + JceOpenSSLPKCS8DecryptorProviderBuilder decryptor = new JceOpenSSLPKCS8DecryptorProviderBuilder().setProvider(provider); + pkInfo = ((PKCS8EncryptedPrivateKeyInfo) object).decryptPrivateKeyInfo(decryptor.build(password)); + } else if (object instanceof PrivateKeyInfo) { + pkInfo = (PrivateKeyInfo) object; + } else { + continue; + } + return converter.getPrivateKey(pkInfo); + } + return null; + } catch (OperatorCreationException | PKCSException e) { + throw new GeneralSecurityException(e); + } + } + + @Override + public MessageDigest createDigest(String algorithm) throws NoSuchAlgorithmException { + return MessageDigest.getInstance(algorithm, getProvider()); + } + + @Override + public Signature createSignature(String algorithm) throws NoSuchAlgorithmException { + return Signature.getInstance(algorithm, getProvider()); + } +} diff --git a/graalpython/com.oracle.graal.python.cext/AGENTS.md b/graalpython/com.oracle.graal.python.cext/AGENTS.md new file mode 100644 index 0000000000..2fec21bb92 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/AGENTS.md @@ -0,0 +1,20 @@ +# com.oracle.graal.python.cext/ — CPYTHON C-API COMPAT + +## OVERVIEW +C headers and native code implementing CPython C-API compatibility plus adapted builtin extension modules. + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Public C-API headers | `include/` | Mirrors CPython header structure. | +| Core C-API impl | `src/` | CPython-like file naming (`unicodeobject.c`, `typeobject.c`, ...). | +| Adapted extension modules | `modules/` | Large upstream-derived modules (e.g., `_sqlite`). | +| Embedded/third-party imports | `expat/`, `modules/_sqlite/sqlite/` | Treat as upstream; patch minimally. | + +## CONVENTIONS / GOTCHAS +- Follow CPython invariants in headers (examples: do not nest `Py_BEGIN_ALLOW_THREADS`; “never mix allocators†warnings). +- Large unicode databases/headers are often generated (e.g., `unicodename_db.h`, `unicodedata_db.h`): avoid hand edits. + +## ANTI-PATTERNS +- **NEVER** nest `Py_BEGIN_ALLOW_THREADS` blocks (see `include/ceval.h`). +- Never mix `PyMem_*` / `PyObject_*` allocators with platform `malloc` family. diff --git a/graalpython/com.oracle.graal.python.cext/CMakeLists.txt b/graalpython/com.oracle.graal.python.cext/CMakeLists.txt index 4ec7d76a9b..8ad41ba7bd 100644 --- a/graalpython/com.oracle.graal.python.cext/CMakeLists.txt +++ b/graalpython/com.oracle.graal.python.cext/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (c) 2023, 2025, Oracle and/or its affiliates. +# Copyright (c) 2023, 2026, Oracle and/or its affiliates. # # All rights reserved. # @@ -37,6 +37,16 @@ endfunction() set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +execute_process(COMMAND ${CMAKE_COMMAND} -E touch "${CMAKE_SOURCE_DIR}/.compile_commands.json.probe" RESULT_VARIABLE _touch_res) +if(_touch_res EQUAL 0) + file(REMOVE "${CMAKE_SOURCE_DIR}/.compile_commands.json.probe") + add_custom_target(compile_commands_target ALL + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_BINARY_DIR}/compile_commands.json" "${CMAKE_SOURCE_DIR}") +else() + message(STATUS "Source directory is not writable, skipping copy of compile_commands.json.") + add_custom_target(compile_commands_target) +endif() + require_var(GRAALPY_PARENT_DIR) require_var(CAPI_INC_DIR) require_var(PYCONFIG_INCLUDE_DIR) @@ -53,6 +63,10 @@ set(TARGET_LIBPYTHON "python-native") # common variables and compile/link options (for all build targets) ###################################################################### +set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE) +set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE) +set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_DEBUG FALSE) + if (MSVC) SET(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "" FORCE) SET(CFLAGS_WARNINGS /Wall /WX @@ -107,7 +121,6 @@ endif() # preprocessor defines for all platforms add_compile_definitions( - NDEBUG WITH_FREELISTS=1 ) @@ -149,7 +162,7 @@ set(SRC_FILES ${CAPI_SRC}/codecs.c ${CAPI_SRC}/setobject.c ${CAPI_SRC}/compile.c ${CAPI_SRC}/fileobject.c ${CAPI_SRC}/pystrcmp.c ${CAPI_SRC}/getversion.c ${CAPI_SRC}/genobject.c ${CAPI_SRC}/methodobject.c ${CAPI_SRC}/boolobject.c ${CAPI_SRC}/pylifecycle.c ${CAPI_SRC}/errors.c ${CAPI_SRC}/signals.c ${CAPI_SRC}/datetime.c ${CAPI_SRC}/call.c - ${CAPI_SRC}/getargs.c ${CAPI_SRC}/tracemalloc.c ${CAPI_SRC}/initconfig.c + ${CAPI_SRC}/getargs.c ${CAPI_SRC}/tracemalloc.c ${CAPI_SRC}/initconfig.c ${CAPI_SRC}/graalpy_stacktrace.c ) file(GLOB_RECURSE ACTUAL_SRC_FILES @@ -321,7 +334,6 @@ if(WIN32) endif() simple_native_module("_testmultiphase") simple_native_module("_testsinglephase") -simple_native_module("_ctypes_test") if(NOT WIN32) ###################### BZIP2 ######################## @@ -356,6 +368,81 @@ target_compile_definitions(${TARGET_PYEXPAT} PRIVATE XML_DTD=1 ) +###################### CTYPES ###################### +native_module("_ctypes_test" TRUE "${SRC_DIR}/modules/_ctypes/_ctypes_test.c") +if(WIN32) + target_compile_definitions("_ctypes_test" PRIVATE MS_WIN32 MS_WINDOWS) +endif() +set(CTYPES_SRC + "${SRC_DIR}/modules/_ctypes/_ctypes.c" + "${SRC_DIR}/modules/_ctypes/callbacks.c" + "${SRC_DIR}/modules/_ctypes/callproc.c" + "${SRC_DIR}/modules/_ctypes/cfield.c" + "${SRC_DIR}/modules/_ctypes/ctypes.h" + "${SRC_DIR}/modules/_ctypes/stgdict.c" +) +native_module("_ctypes" TRUE "${CTYPES_SRC}") +if(WIN32) + target_compile_definitions("_ctypes" PRIVATE MS_WIN32 MS_WINDOWS) +endif() +target_include_directories("_ctypes" PUBLIC "${SRC_DIR}/modules/_ctypes") +find_library(FFI_LIBRARY + NAMES "ffi.lib" "libffi.a" + PATHS "${LIBFFI_DIST}" + REQUIRED + NO_DEFAULT_PATH + NO_PACKAGE_ROOT_PATH + NO_CMAKE_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH + NO_CMAKE_INSTALL_PREFIX +) +find_path(FFI_INCLUDE + NAMES "ffi.h" + PATHS "${LIBFFI_DIST}" + PATH_SUFFIXES "include" + REQUIRED + NO_DEFAULT_PATH + NO_PACKAGE_ROOT_PATH + NO_CMAKE_PATH + NO_CMAKE_ENVIRONMENT_PATH + NO_SYSTEM_ENVIRONMENT_PATH + NO_CMAKE_SYSTEM_PATH + NO_CMAKE_INSTALL_PREFIX +) +target_link_libraries("_ctypes" PRIVATE ${FFI_LIBRARY}) + +target_include_directories("_ctypes" BEFORE PRIVATE ${FFI_INCLUDE}) + +if(WIN32) + target_compile_options("_ctypes" PRIVATE + /wd4201 # ffi.h(332): warning C4201: nonstandard extension used: nameless struct/union + /wd4457 # _ctypes.c(4783): warning C4457: declaration of 'item' hides function parameter + ) + target_compile_definitions("_ctypes" PRIVATE + MS_WIN32 + MS_WIN64 + _WIN64 + FFI_STATIC_BUILD + ) +elseif(APPLE) + target_compile_definitions("_ctypes" PRIVATE + HAVE_DECL_RTLD_LOCAL + HAVE_DECL_RTLD_GLOBAL + HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH + HAVE_FFI_CLOSURE_ALLOC + HAVE_FFI_PREP_CIF_VAR + HAVE_FFI_PREP_CLOSURE_LOC + ) +else() + target_compile_definitions("_ctypes" PRIVATE + HAVE_DECL_RTLD_LOCAL + HAVE_DECL_RTLD_GLOBAL + ) +endif() + +###################### LIBPYTHON ###################### target_sources(${TARGET_LIBPYTHON} PRIVATE ${SRC_FILES}) target_include_directories(${TARGET_LIBPYTHON} PRIVATE "${SRC_DIR}/include/internal" @@ -372,6 +459,7 @@ if(WIN32) if (NOT MSVC) target_compile_options(${TARGET_LIBPYTHON} PRIVATE "-fmsc-version=1920") endif() + target_link_libraries(${TARGET_LIBPYTHON} dbghelp) else() # Link to math library; required for functions like 'hypot' or similar target_link_libraries(${TARGET_LIBPYTHON} m) diff --git a/graalpython/com.oracle.graal.python.cext/compile_flags.txt b/graalpython/com.oracle.graal.python.cext/compile_flags.txt deleted file mode 100644 index c61a5c5ed0..0000000000 --- a/graalpython/com.oracle.graal.python.cext/compile_flags.txt +++ /dev/null @@ -1,2 +0,0 @@ --Iinclude/ --I../include/ diff --git a/graalpython/com.oracle.graal.python.cext/expat/xmltok_ns.c b/graalpython/com.oracle.graal.python.cext/expat/xmltok_ns.c index 919c74e9f9..d0310c1904 100644 --- a/graalpython/com.oracle.graal.python.cext/expat/xmltok_ns.c +++ b/graalpython/com.oracle.graal.python.cext/expat/xmltok_ns.c @@ -90,6 +90,9 @@ static const ENCODING * NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) { # define ENCODING_MAX 128 char buf[ENCODING_MAX]; +#ifndef NDEBUG // GraalPy change: satisfy compiler for debug build + memset(buf, '\0', sizeof(buf)); +#endif // GraalPy change char *p = buf; int i; XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1); diff --git a/graalpython/com.oracle.graal.python.cext/include/Python.h b/graalpython/com.oracle.graal.python.cext/include/Python.h index a653aa8ea2..00e286ff9e 100644 --- a/graalpython/com.oracle.graal.python.cext/include/Python.h +++ b/graalpython/com.oracle.graal.python.cext/include/Python.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2022, 2024, Oracle and/or its affiliates. +/* Copyright (c) 2022, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -100,6 +100,7 @@ struct timeval; #include "pythonrun.h" #include "pylifecycle.h" #include "ceval.h" +#include "intrcheck.h" #include "sysmodule.h" #include "osmodule.h" #include "import.h" diff --git a/graalpython/com.oracle.graal.python.cext/include/cpython/dictobject.h b/graalpython/com.oracle.graal.python.cext/include/cpython/dictobject.h index dff67c9db6..6e85a74ea6 100644 --- a/graalpython/com.oracle.graal.python.cext/include/cpython/dictobject.h +++ b/graalpython/com.oracle.graal.python.cext/include/cpython/dictobject.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2020, 2024, Oracle and/or its affiliates. +/* Copyright (c) 2020, 2025, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 diff --git a/graalpython/com.oracle.graal.python.cext/include/cpython/pystate.h b/graalpython/com.oracle.graal.python.cext/include/cpython/pystate.h index 588fae9f29..cd1897bca7 100644 --- a/graalpython/com.oracle.graal.python.cext/include/cpython/pystate.h +++ b/graalpython/com.oracle.graal.python.cext/include/cpython/pystate.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2020, 2024, Oracle and/or its affiliates. +/* Copyright (c) 2020, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -105,6 +105,18 @@ typedef struct _err_stackitem { } _PyErr_StackItem; +typedef struct { + PyObject **items; + int len; + int capacity; +} GraalPyDeallocState; + +typedef struct { + PyObject *tuple_empty; + PyObject *bytes_empty; + PyObject **bytes_characters; +} GraalPySingletons; + typedef struct _stack_chunk { struct _stack_chunk *previous; size_t size; @@ -259,9 +271,20 @@ struct _ts { */ PyObject **small_ints; + /* GraalPy change: Similar to small_ints, we keep native wrappers for + CPython's internal static-object singletons in the PyThreadState rather + than in PyInterpreterState or _PyRuntimeState. The native wrappers are + context-local handle-space pointers even though the represented managed + objects are immutable. Do not add public API singletons such as Py_None + here; CPython exposes those through their dedicated globals. */ + GraalPySingletons singletons; + /* GraalPy change: We add field 'gc' which corresponds to field '&interp->gc'. */ struct _gc_runtime_state *gc; + + /* GraalPy change: stack of native objects currently being deallocated. */ + GraalPyDeallocState graalpy_deallocating; }; /* WASI has limited call stack. Python's recursion limit depends on code diff --git a/graalpython/com.oracle.graal.python.cext/include/cpython/tupleobject.h b/graalpython/com.oracle.graal.python.cext/include/cpython/tupleobject.h index b946ab75c3..0b4546a700 100644 --- a/graalpython/com.oracle.graal.python.cext/include/cpython/tupleobject.h +++ b/graalpython/com.oracle.graal.python.cext/include/cpython/tupleobject.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2020, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2020, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -12,8 +12,7 @@ typedef struct { /* ob_item contains space for 'ob_size' elements. Items must normally not be NULL, except during construction when the tuple is not yet visible outside the function that builds it. */ - // Truffle change: PyObject *ob_item[1] doesn't work for us in Sulong - PyObject **Py_HIDE_IMPL_FIELD(ob_item); + PyObject *ob_item[1]; } PyTupleObject; PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); diff --git a/graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h b/graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h index 9cafa91aaf..21e346e825 100644 --- a/graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h +++ b/graalpython/com.oracle.graal.python.cext/include/graalpy/handles.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -45,12 +45,50 @@ #include #define MANAGED_REFCNT 10 -#define HANDLE_BASE 0x8000000000000000ULL + +/* + * We cannot do NaN tagging. Even if we rely on running systems that use at + * most 48 bits for their adresses (so not running with PML5/la57 enabled), we + * do not control all allocations, so PyObject* allocated somewhere else will + * not be tagged and thus are indistinguishable from subnormal floating point + * values or +0.0 for NULL values. Additionally, we know that at least cffi + * uses tagging of the low 3 alignment bits o PyObject* and thus those also + * need to be 0 for anything we hand out. So we can realistically only use the + * upper 16 and lower 45 bits, which isn't enough to do NaN tagging (unless we + * want to do weird stuff like disallow certain double bit patterns). So the + * thing we can do is to tag managed pointers, 32-bit integers, and double + * values that fit into single-precision floats without loss. + */ + +// Aligned with the same constants in CApiTransitions. Update comment there if +// you change or move these. +#define HANDLE_TAG_BIT ((uint64_t)(1ULL << 63)) +#define INTEGER_TAG_BIT ((uint64_t)(1ULL << 62)) +#define FLOAT_TAG_BIT ((uint64_t)(1ULL << 61)) + // IMMORTAL_REFCNT value is aligned with include/object.h #define IMMORTAL_REFCNT 0xFFFFFFFFL +#define _35_BIT_MASK (0xFFFFFFFFULL << 3) + +#define points_to_py_handle_space(PTR) (((uint64_t)(uintptr_t)(PTR)) & HANDLE_TAG_BIT) +#define points_to_py_int_handle(PTR) (((uint64_t)(uintptr_t)(PTR)) & INTEGER_TAG_BIT) +#define points_to_py_float_handle(PTR) (((uint64_t)(uintptr_t)(PTR)) & FLOAT_TAG_BIT) + +#define stub_to_pointer(STUB_PTR) ((uintptr_t)(((uint64_t)(uintptr_t)(STUB_PTR)) | HANDLE_TAG_BIT)) +#define int32_to_pointer(INT) ((uintptr_t)((((uint64_t)(uint32_t)(INT) << 3) & _35_BIT_MASK) | HANDLE_TAG_BIT | INTEGER_TAG_BIT)) +static inline PyObject* float_to_pointer(float dbl) { + uint32_t float_bits; + memcpy(&float_bits, &dbl, sizeof(float)); + return (PyObject *)(uintptr_t)(((((uint64_t)float_bits) << 3) & _35_BIT_MASK) | HANDLE_TAG_BIT | FLOAT_TAG_BIT); +} -#define points_to_py_handle_space(PTR) ((((uintptr_t) (PTR)) & HANDLE_BASE) != 0) -#define stub_to_pointer(STUB_PTR) (((uintptr_t) (STUB_PTR)) | HANDLE_BASE) -#define pointer_to_stub(PTR) ((PyObject *)(((uintptr_t) (PTR)) & ~HANDLE_BASE)) +#define pointer_to_stub(PTR) ((PyObject*)(((uint64_t)(uintptr_t)(PTR)) & ~HANDLE_TAG_BIT)) +#define pointer_to_int64(PTR) ((int64_t)(int32_t)(((uint64_t)(uintptr_t)(PTR)) >> 3)) +static inline double pointer_to_double(PyObject* ptr) { + uint32_t float_bits = (uint32_t)(((uint64_t)(uintptr_t)ptr) >> 3); + float value; + memcpy(&value, &float_bits, sizeof(float)); + return (double)value; +} #endif /* SRC_HANDLES_H_ */ diff --git a/graalpython/com.oracle.graal.python.cext/include/graalpy/testcapi.h b/graalpython/com.oracle.graal.python.cext/include/graalpy/testcapi.h new file mode 100644 index 0000000000..6b3f9b17d9 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/include/graalpy/testcapi.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef GRAALPY_TESTCAPI_H +#define GRAALPY_TESTCAPI_H + +#ifndef GRAALPY_ENABLE_TESTING_CAPI +# error "graalpy/testcapi.h is only available if GRAALPY_ENABLE_TESTING_CAPI is defined" +#endif + +#include +#include +#include + +#define GraalPy_Test_CAPI_NAME "__graalpython__._testcapi" + +typedef struct { + int (*ToNative)(void *); + int (*DisableReferenceQueuePolling)(void); + void (*EnableReferenceQueuePolling)(void); + void (*TriggerGC)(size_t); + uintptr_t (*LongLvTag)(const PyLongObject *); + void (*GraalPyPrivate_LogImpl)(int, const char *, va_list); +} GraalPy_Test_CAPI; + +static GraalPy_Test_CAPI *GraalPyTestCAPI = NULL; + +static inline int GraalPyTestCAPI_Import(void) { + GraalPyTestCAPI = (GraalPy_Test_CAPI *) PyCapsule_Import(GraalPy_Test_CAPI_NAME, 0); + return GraalPyTestCAPI == NULL ? -1 : 0; +} + +#endif diff --git a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h index 2573716e4e..4f7554d45e 100644 --- a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h +++ b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_gc.h @@ -33,7 +33,7 @@ static inline PyGC_Head* _Py_AS_GC(PyObject *op) { #define _PyGC_Head_UNUSED PyGC_Head // GraalPy change -#define _PyGCHead_UNTAG(PTR) ((PyGC_Head *)(((uintptr_t) (PTR)) & ~HANDLE_BASE)) +#define _PyGCHead_UNTAG(PTR) ((PyGC_Head *)(((uintptr_t) (PTR)) & ~HANDLE_TAG_BIT)) /* True if the object is currently tracked by the GC. */ static inline int _PyObject_GC_IS_TRACKED(PyObject *op) { diff --git a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_global_objects.h b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_global_objects.h index 65832418e9..2c4ed78c32 100644 --- a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_global_objects.h +++ b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_global_objects.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2023 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -35,8 +35,11 @@ extern "C" { #define _Py_GLOBAL_OBJECT(NAME) \ _PyRuntime.static_objects.NAME +/* GraalPy change: CPython exposes static singleton storage through _PyRuntime. + GraalPy's native wrappers are context-local handle-space pointers, so keep + them in the PyThreadState next to small_ints. */ #define _Py_SINGLETON(NAME) \ - _Py_GLOBAL_OBJECT(singletons.NAME) + (*(PyThreadState_Get()->singletons.NAME)) #if 0 // GraalPy change struct _Py_cached_objects { diff --git a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_long.h b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_long.h index 8cf0375c1a..97f2defa88 100644 --- a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_long.h +++ b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_long.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2022, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2022, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -64,7 +64,6 @@ extern void _PyLong_FiniTypes(PyInterpreterState *interp); /* GraalVM change #define _PyLong_SMALL_INTS _Py_SINGLETON(small_ints) */ -#define _PyLong_SMALL_INT_PTRS (PyThreadState_GET()->small_ints) // Return a borrowed reference to the zero singleton. // The function cannot return NULL. @@ -72,7 +71,7 @@ static inline PyObject* _PyLong_GetZero(void) /* GraalVM change { return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS]; } */ -{ return _PyLong_SMALL_INT_PTRS[_PY_NSMALLNEGINTS]; } +{ return int32_to_pointer(0); } // Return a borrowed reference to the one singleton. // The function cannot return NULL. @@ -80,7 +79,7 @@ static inline PyObject* _PyLong_GetOne(void) /* GraalVM change { return (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+1]; } */ -{ return _PyLong_SMALL_INT_PTRS[_PY_NSMALLNEGINTS+1]; } +{ return int32_to_pointer(1); } static inline PyObject* _PyLong_FromUnsignedChar(unsigned char i) { @@ -127,7 +126,7 @@ PyAPI_FUNC(char*) _PyLong_FormatBytesWriter( #define SIGN_NEGATIVE 2 #define NON_SIZE_BITS 3 -PyAPI_FUNC(uintptr_t) GraalPyPrivate_Long_lv_tag(const PyLongObject *op); +Py_LOCAL_SYMBOL uintptr_t GraalPyPrivate_Long_lv_tag(const PyLongObject *op); /* The functions _PyLong_IsCompact and _PyLong_CompactValue are defined * in Include/cpython/longobject.h, since they need to be inline. * diff --git a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_object.h b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_object.h index 6485448451..c2251550a0 100644 --- a/graalpython/com.oracle.graal.python.cext/include/internal/pycore_object.h +++ b/graalpython/com.oracle.graal.python.cext/include/internal/pycore_object.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2022, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2022, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -367,14 +367,17 @@ _PyObject_IS_GC(PyObject *obj) static inline size_t _PyType_PreHeaderSize(PyTypeObject *tp) { - // GraalPy change: we put only one pointer for dict, we don't store it inlined [GR-61996] + /* Note: the pre-header size must have a 16-byte alignment. This is + necessary for higher optimization levels which assume the alignment + (inferred from the struct size) and emit instructions that require + this alignment. */ return _PyType_IS_GC(tp) * sizeof(PyGC_Head) + - _PyType_HasFeature(tp, Py_TPFLAGS_PREHEADER) * /* 2 * */ sizeof(PyObject *); + _PyType_HasFeature(tp, Py_TPFLAGS_PREHEADER) * 2 * sizeof(PyObject *); } void _PyObject_GC_Link(PyObject *op); -PyAPI_FUNC(void) _GraalPyObject_GC_NotifyOwnershipTransfer(PyObject *op); +Py_LOCAL_SYMBOL void _GraalPyObject_GC_NotifyOwnershipTransfer(PyObject *op); // Usage: assert(_Py_CheckSlotResult(obj, "__getitem__", result != NULL)); extern int _Py_CheckSlotResult( diff --git a/graalpython/com.oracle.graal.python.cext/include/intrcheck.h b/graalpython/com.oracle.graal.python.cext/include/intrcheck.h new file mode 100644 index 0000000000..2c940799b2 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/include/intrcheck.h @@ -0,0 +1,34 @@ +/* Copyright (c) 2026, Oracle and/or its affiliates. + * Copyright (C) 1996-2020 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ + +#ifndef Py_INTRCHECK_H +#define Py_INTRCHECK_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(int) PyOS_InterruptOccurred(void); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 +PyAPI_FUNC(void) PyOS_BeforeFork(void); +PyAPI_FUNC(void) PyOS_AfterFork_Parent(void); +PyAPI_FUNC(void) PyOS_AfterFork_Child(void); +#endif +/* Deprecated, please use PyOS_AfterFork_Child() instead */ +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); + +#ifndef Py_LIMITED_API +PyAPI_FUNC(int) _PyOS_IsMainThread(void); + +#ifdef MS_WINDOWS +/* windows.h is not included by Python.h so use void* instead of HANDLE */ +PyAPI_FUNC(void*) _PyOS_SigintEvent(void); +#endif +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTRCHECK_H */ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_cpython_sre/sre.c b/graalpython/com.oracle.graal.python.cext/modules/_cpython_sre/sre.c index e91eee1a3e..d9aeca3d67 100644 --- a/graalpython/com.oracle.graal.python.cext/modules/_cpython_sre/sre.c +++ b/graalpython/com.oracle.graal.python.cext/modules/_cpython_sre/sre.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -45,7 +45,6 @@ static const char copyright[] = #define PY_SSIZE_T_CLEAN -#include "capi.h" // GraalPy change #include "Python.h" #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_moduleobject.h" // _PyModule_GetState() @@ -3051,14 +3050,19 @@ expand_template(TemplateObject *self, MatchObject *match) #if 0 // GraalPy change result = _PyUnicode_JoinArray(&_Py_STR(empty), out, count); #else // GraalPy change: different implementation - count = GraalPyPrivate_List_TryGetItems(list, &out); - result = _PyUnicode_JoinArray(PyUnicode_FromString(""), out, count); + count = PyList_GET_SIZE(list); + out = GraalPyList_ITEMS(list); + PyObject *empty = PyUnicode_FromString(""); + if (empty == NULL) { + goto cleanup; + } + result = _PyUnicode_JoinArray(empty, out, count); + Py_DECREF(empty); #endif // GraalPy change } else { // Py_SET_SIZE(list, count); // GraalPy change - // GraalPy change: replace '&_Py_SINGLETON(bytes_empty)' with 'GraalPyPrivate_Bytes_EmptyWithCapacity(0)' - result = _PyBytes_Join(GraalPyPrivate_Bytes_EmptyWithCapacity(0), list); + result = _PyBytes_Join((PyObject *)&_Py_SINGLETON(bytes_empty), list); } cleanup: diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes.c new file mode 100644 index 0000000000..8eaf0a9aee --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes.c @@ -0,0 +1,5881 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +/* + ToDo: + + Get rid of the checker (and also the converters) field in PyCFuncPtrObject and + StgDictObject, and replace them by slot functions in StgDictObject. + + think about a buffer-like object (memory? bytes?) + + Should POINTER(c_char) and POINTER(c_wchar) have a .value property? + What about c_char and c_wchar arrays then? + + Add from_mmap, from_file, from_string metaclass methods. + + Maybe we can get away with from_file (calls read) and with a from_buffer + method? + + And what about the to_mmap, to_file, to_str(?) methods? They would clobber + the namespace, probably. So, functions instead? And we already have memmove... +*/ + +/* + +Name methods, members, getsets +============================================================================== + +PyCStructType_Type __new__(), from_address(), __mul__(), from_param() +UnionType_Type __new__(), from_address(), __mul__(), from_param() +PyCPointerType_Type __new__(), from_address(), __mul__(), from_param(), set_type() +PyCArrayType_Type __new__(), from_address(), __mul__(), from_param() +PyCSimpleType_Type __new__(), from_address(), __mul__(), from_param() + +PyCData_Type + Struct_Type __new__(), __init__() + PyCPointer_Type __new__(), __init__(), _as_parameter_, contents + PyCArray_Type __new__(), __init__(), _as_parameter_, __get/setitem__(), __len__() + Simple_Type __new__(), __init__(), _as_parameter_ + +PyCField_Type +PyCStgDict_Type + +============================================================================== + +class methods +------------- + +It has some similarity to the byref() construct compared to pointer() +from_address(addr) + - construct an instance from a given memory block (sharing this memory block) + +from_param(obj) + - typecheck and convert a Python object into a C function call parameter + The result may be an instance of the type, or an integer or tuple + (typecode, value[, obj]) + +instance methods/properties +--------------------------- + +_as_parameter_ + - convert self into a C function call parameter + This is either an integer, or a 3-tuple (typecode, value, obj) + +functions +--------- + +sizeof(cdata) + - return the number of bytes the buffer contains + +sizeof(ctype) + - return the number of bytes the buffer of an instance would contain + +byref(cdata) + +addressof(cdata) + +pointer(cdata) + +POINTER(ctype) + +bytes(cdata) + - return the buffer contents as a sequence of bytes (which is currently a string) + +*/ + +/* + * PyCStgDict_Type + * PyCStructType_Type + * UnionType_Type + * PyCPointerType_Type + * PyCArrayType_Type + * PyCSimpleType_Type + * + * PyCData_Type + * Struct_Type + * Union_Type + * PyCArray_Type + * Simple_Type + * PyCPointer_Type + * PyCField_Type + * + */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#define PY_SSIZE_T_CLEAN + +#include "Python.h" +// windows.h must be included before pycore internal headers +#ifdef MS_WIN32 +# include +#endif + +#include "pycore_call.h" // _PyObject_CallNoArgs() +#include "pycore_ceval.h" // _Py_EnterRecursiveCall() +#include "structmember.h" // PyMemberDef + +#include +#ifdef MS_WIN32 +#include +#ifndef IS_INTRESOURCE +#define IS_INTRESOURCE(x) (((size_t)(x) >> 16) == 0) +#endif +#else +#include +#endif +#include "ctypes.h" + +#include "pycore_long.h" // _PyLong_GetZero() + +#if 1 // GraalPy change +// Assign a stgdict to type's tp_dict slot. In GraalPy we do not track our +// builtin dicts, and type dicts for managed classes actually have no tp_dict +// with an extra native ref, they are kept alive by the type only and their +// handles are collected by the GC or on context shutdown. So when we assign a +// fresh stgdict to the type's tp_dict, we make it also have only +// MANAGED_REFCOUNT and let it be collected when the type is collected. +#define set_graalpy_tp_dict(type, stgdict) \ + { \ + PyObject *__stgdict = (PyObject *)(stgdict); \ + PyTypeObject *__type = (PyTypeObject *)(type); \ + PyObject_GC_UnTrack(__stgdict); \ + if (points_to_py_handle_space(__type)) { \ + _PyObject_ASSERT_FAILED_MSG((PyObject*) __type, \ + "type dict has increased refcnt, " \ + "something changed in how GraalPy " \ + "marries classes to native structs"); \ + } \ + if (Py_REFCNT(__type->tp_dict) != MANAGED_REFCNT) { \ + _PyObject_ASSERT_FAILED_MSG((PyObject*) __type, \ + "type dict has increased refcnt, " \ + "something changed in how GraalPy " \ + "marries classes to native structs"); \ + } \ + if (Py_REFCNT(__stgdict) != MANAGED_REFCNT + 1) { \ + _PyObject_ASSERT_FAILED_MSG(__stgdict, \ + "new stgdict has incorrect refcnt, " \ + "something changed in GraalPy"); \ + } \ + __type->tp_dict = (PyObject *)__stgdict; \ + PyType_Modified(__type); \ + Py_DecRef(__stgdict); \ + } +#endif + +ctypes_state global_state; + +PyObject *PyExc_ArgError = NULL; + +/* This dict maps ctypes types to POINTER types */ +PyObject *_ctypes_ptrtype_cache = NULL; + +static PyTypeObject Simple_Type; + +/* a callable object used for unpickling: + strong reference to _ctypes._unpickle() function */ +static PyObject *_unpickle; + + +/****************************************************************/ + +typedef struct { + PyObject_HEAD + PyObject *key; + PyObject *dict; +} DictRemoverObject; + +static int +_DictRemover_traverse(DictRemoverObject *self, visitproc visit, void *arg) +{ + Py_VISIT(Py_TYPE(self)); + Py_VISIT(self->key); + Py_VISIT(self->dict); + return 0; +} + +static int +_DictRemover_clear(DictRemoverObject *self) +{ + Py_CLEAR(self->key); + Py_CLEAR(self->dict); + return 0; +} + +static void +_DictRemover_dealloc(PyObject *myself) +{ + PyTypeObject *tp = Py_TYPE(myself); + DictRemoverObject *self = (DictRemoverObject *)myself; + PyObject_GC_UnTrack(myself); + (void)_DictRemover_clear(self); + tp->tp_free(myself); + Py_DECREF(tp); +} + +static PyObject * +_DictRemover_call(PyObject *myself, PyObject *args, PyObject *kw) +{ + DictRemoverObject *self = (DictRemoverObject *)myself; + if (self->key && self->dict) { + if (-1 == PyDict_DelItem(self->dict, self->key)) { + _PyErr_WriteUnraisableMsg("on calling _ctypes.DictRemover", NULL); + } + Py_CLEAR(self->key); + Py_CLEAR(self->dict); + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(dictremover_doc, "deletes a key from a dictionary"); + +static PyType_Slot dictremover_slots[] = { + {Py_tp_dealloc, _DictRemover_dealloc}, + {Py_tp_traverse, _DictRemover_traverse}, + {Py_tp_clear, _DictRemover_clear}, + {Py_tp_call, _DictRemover_call}, + {Py_tp_doc, (void *)dictremover_doc}, + {0, NULL}, +}; + +static PyType_Spec dictremover_spec = { + .name = "_ctypes.DictRemover", + .basicsize = sizeof(DictRemoverObject), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE), + .slots = dictremover_slots, +}; + +int +PyDict_SetItemProxy(PyObject *dict, PyObject *key, PyObject *item) +{ + PyObject *obj; + DictRemoverObject *remover; + PyObject *proxy; + int result; + + ctypes_state *st = GLOBAL_STATE(); + obj = _PyObject_CallNoArgs((PyObject *)st->DictRemover_Type); + if (obj == NULL) + return -1; + + remover = (DictRemoverObject *)obj; + assert(remover->key == NULL); + assert(remover->dict == NULL); + remover->key = Py_NewRef(key); + remover->dict = Py_NewRef(dict); + + proxy = PyWeakref_NewProxy(item, obj); + Py_DECREF(obj); + if (proxy == NULL) + return -1; + + result = PyDict_SetItem(dict, key, proxy); + Py_DECREF(proxy); + return result; +} + +PyObject * +PyDict_GetItemProxy(PyObject *dict, PyObject *key) +{ + PyObject *result; + PyObject *item = PyDict_GetItemWithError(dict, key); + + if (item == NULL) + return NULL; + if (!PyWeakref_CheckProxy(item)) + return item; + result = PyWeakref_GET_OBJECT(item); + if (result == Py_None) + return NULL; + return result; +} + +/******************************************************************/ + +/* + Allocate a memory block for a pep3118 format string, filled with + a suitable PEP 3118 type code corresponding to the given ctypes + type. Returns NULL on failure, with the error indicator set. + + This produces type codes in the standard size mode (cf. struct module), + since the endianness may need to be swapped to a non-native one + later on. + */ +static char * +_ctypes_alloc_format_string_for_type(char code, int big_endian) +{ + char *result; + char pep_code = '\0'; + + switch (code) { +#if SIZEOF_INT == 2 + case 'i': pep_code = 'h'; break; + case 'I': pep_code = 'H'; break; +#elif SIZEOF_INT == 4 + case 'i': pep_code = 'i'; break; + case 'I': pep_code = 'I'; break; +#elif SIZEOF_INT == 8 + case 'i': pep_code = 'q'; break; + case 'I': pep_code = 'Q'; break; +#else +# error SIZEOF_INT has an unexpected value +#endif /* SIZEOF_INT */ +#if SIZEOF_LONG == 4 + case 'l': pep_code = 'l'; break; + case 'L': pep_code = 'L'; break; +#elif SIZEOF_LONG == 8 + case 'l': pep_code = 'q'; break; + case 'L': pep_code = 'Q'; break; +#else +# error SIZEOF_LONG has an unexpected value +#endif /* SIZEOF_LONG */ +#if SIZEOF__BOOL == 1 + case '?': pep_code = '?'; break; +#elif SIZEOF__BOOL == 2 + case '?': pep_code = 'H'; break; +#elif SIZEOF__BOOL == 4 + case '?': pep_code = 'L'; break; +#elif SIZEOF__BOOL == 8 + case '?': pep_code = 'Q'; break; +#else +# error SIZEOF__BOOL has an unexpected value +#endif /* SIZEOF__BOOL */ + default: + /* The standard-size code is the same as the ctypes one */ + pep_code = code; + break; + } + + result = PyMem_Malloc(3); + if (result == NULL) { + PyErr_NoMemory(); + return NULL; + } + + result[0] = big_endian ? '>' : '<'; + result[1] = pep_code; + result[2] = '\0'; + return result; +} + +/* + Allocate a memory block for a pep3118 format string, copy prefix (if + non-null) and suffix into it. Returns NULL on failure, with the error + indicator set. If called with a suffix of NULL the error indicator must + already be set. + */ +char * +_ctypes_alloc_format_string(const char *prefix, const char *suffix) +{ + size_t len; + char *result; + + if (suffix == NULL) { + assert(PyErr_Occurred()); + return NULL; + } + len = strlen(suffix); + if (prefix) + len += strlen(prefix); + result = PyMem_Malloc(len + 1); + if (result == NULL) { + PyErr_NoMemory(); + return NULL; + } + if (prefix) + strcpy(result, prefix); + else + result[0] = '\0'; + strcat(result, suffix); + return result; +} + +/* + Allocate a memory block for a pep3118 format string, adding + the given prefix (if non-null), an additional shape prefix, and a suffix. + Returns NULL on failure, with the error indicator set. If called with + a suffix of NULL the error indicator must already be set. + */ +char * +_ctypes_alloc_format_string_with_shape(int ndim, const Py_ssize_t *shape, + const char *prefix, const char *suffix) +{ + char *new_prefix; + char *result; + char buf[32]; + Py_ssize_t prefix_len; + int k; + + prefix_len = 32 * ndim + 3; + if (prefix) + prefix_len += strlen(prefix); + new_prefix = PyMem_Malloc(prefix_len); + if (new_prefix == NULL) { + PyErr_NoMemory(); + return NULL; + } + new_prefix[0] = '\0'; + if (prefix) + strcpy(new_prefix, prefix); + if (ndim > 0) { + /* Add the prefix "(shape[0],shape[1],...,shape[ndim-1])" */ + strcat(new_prefix, "("); + for (k = 0; k < ndim; ++k) { + if (k < ndim-1) { + sprintf(buf, "%zd,", shape[k]); + } else { + sprintf(buf, "%zd)", shape[k]); + } + strcat(new_prefix, buf); + } + } + result = _ctypes_alloc_format_string(new_prefix, suffix); + PyMem_Free(new_prefix); + return result; +} + +/* StructParamObject and StructParam_Type are used in _ctypes_callproc() + for argument.keep to call PyMem_Free(ptr) on Py_DECREF(argument). + + StructUnionType_paramfunc() creates such object when a ctypes Structure is + passed by copy to a C function. */ +typedef struct { + PyObject_HEAD + void *ptr; + PyObject *keep; // If set, a reference to the original CDataObject. +} StructParamObject; + +static int +StructParam_traverse(StructParamObject *self, visitproc visit, void *arg) +{ + Py_VISIT(Py_TYPE(self)); + return 0; +} + +static int +StructParam_clear(StructParamObject *self) +{ + Py_CLEAR(self->keep); + return 0; +} + +static void +StructParam_dealloc(PyObject *myself) +{ + StructParamObject *self = (StructParamObject *)myself; + PyTypeObject *tp = Py_TYPE(self); + PyObject_GC_UnTrack(myself); + (void)StructParam_clear(self); + PyMem_Free(self->ptr); + tp->tp_free(myself); + Py_DECREF(tp); +} + +static PyType_Slot structparam_slots[] = { + {Py_tp_traverse, StructParam_traverse}, + {Py_tp_clear, StructParam_clear}, + {Py_tp_dealloc, StructParam_dealloc}, + {0, NULL}, +}; + +static PyType_Spec structparam_spec = { + .name = "_ctypes.StructParam_Type", + .basicsize = sizeof(StructParamObject), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_DISALLOW_INSTANTIATION), + .slots = structparam_slots, +}; + + +/* + PyCStructType_Type - a meta type/class. Creating a new class using this one as + __metaclass__ will call the constructor StructUnionType_new. It replaces the + tp_dict member with a new instance of StgDict, and initializes the C + accessible fields somehow. +*/ + +static PyCArgObject * +StructUnionType_paramfunc(CDataObject *self) +{ + PyCArgObject *parg; + PyObject *obj; + StgDictObject *stgdict; + void *ptr; + + if ((size_t)self->b_size > sizeof(void*)) { + ptr = PyMem_Malloc(self->b_size); + if (ptr == NULL) { + return NULL; + } + memcpy(ptr, self->b_ptr, self->b_size); + + /* Create a Python object which calls PyMem_Free(ptr) in + its deallocator. The object will be destroyed + at _ctypes_callproc() cleanup. */ + ctypes_state *st = GLOBAL_STATE(); + PyTypeObject *tp = st->StructParam_Type; + obj = tp->tp_alloc(tp, 0); + if (obj == NULL) { + PyMem_Free(ptr); + return NULL; + } + + StructParamObject *struct_param = (StructParamObject *)obj; + struct_param->ptr = ptr; + struct_param->keep = Py_NewRef(self); + } else { + ptr = self->b_ptr; + obj = Py_NewRef(self); + } + + parg = PyCArgObject_new(); + if (parg == NULL) { + Py_DECREF(obj); + return NULL; + } + + parg->tag = 'V'; + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for structure/union instances */ + parg->pffi_type = &stgdict->ffi_type_pointer; + parg->value.p = ptr; + parg->size = self->b_size; + parg->obj = obj; + return parg; +} + +static PyObject * +StructUnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds, int isStruct) +{ + PyTypeObject *result; + PyObject *fields; + StgDictObject *dict; + + /* create the new instance (which is a class, + since we are a metatype!) */ + result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds); + if (!result) + return NULL; + + /* keep this for bw compatibility */ + int r = PyDict_Contains(result->tp_dict, _Py_ID(_abstract_)); + if (r > 0) + return (PyObject *)result; + if (r < 0) { + Py_DECREF(result); + return NULL; + } + + dict = (StgDictObject *)_PyObject_CallNoArgs((PyObject *)&PyCStgDict_Type); + if (!dict) { + Py_DECREF(result); + return NULL; + } + if (!isStruct) { + dict->flags |= TYPEFLAG_HASUNION; + } + /* replace the class dict by our updated stgdict, which holds info + about storage requirements of the instances */ + if (-1 == PyDict_Update((PyObject *)dict, result->tp_dict)) { + Py_DECREF(result); + Py_DECREF((PyObject *)dict); + return NULL; + } + set_graalpy_tp_dict(result, dict); // GraalPy change: do not use Py_SETREF + dict->format = _ctypes_alloc_format_string(NULL, "B"); + if (dict->format == NULL) { + Py_DECREF(result); + return NULL; + } + + dict->paramfunc = StructUnionType_paramfunc; + + fields = PyDict_GetItemWithError((PyObject *)dict, _Py_ID(_fields_)); + if (fields) { + if (PyObject_SetAttr((PyObject *)result, _Py_ID(_fields_), fields) < 0) { + Py_DECREF(result); + return NULL; + } + return (PyObject *)result; + } + else if (PyErr_Occurred()) { + Py_DECREF(result); + return NULL; + } + else { + StgDictObject *basedict = PyType_stgdict((PyObject *)result->tp_base); + + if (basedict == NULL) + return (PyObject *)result; + /* copy base dict */ + if (-1 == PyCStgDict_clone(dict, basedict)) { + Py_DECREF(result); + return NULL; + } + dict->flags &= ~DICTFLAG_FINAL; /* clear the 'final' flag in the subclass dict */ + basedict->flags |= DICTFLAG_FINAL; /* set the 'final' flag in the baseclass dict */ + return (PyObject *)result; + } +} + +static PyObject * +PyCStructType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + return StructUnionType_new(type, args, kwds, 1); +} + +static PyObject * +UnionType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + return StructUnionType_new(type, args, kwds, 0); +} + +PyDoc_STRVAR(from_address_doc, +"C.from_address(integer) -> C instance\naccess a C instance at the specified address"); + +static PyObject * +CDataType_from_address(PyObject *type, PyObject *value) +{ + void *buf; + if (!PyLong_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "integer expected"); + return NULL; + } + buf = (void *)PyLong_AsVoidPtr(value); + if (PyErr_Occurred()) + return NULL; + return PyCData_AtAddress(type, buf); +} + +PyDoc_STRVAR(from_buffer_doc, +"C.from_buffer(object, offset=0) -> C instance\ncreate a C instance from a writeable buffer"); + +static int +KeepRef(CDataObject *target, Py_ssize_t index, PyObject *keep); + +static PyObject * +CDataType_from_buffer(PyObject *type, PyObject *args) +{ + PyObject *obj; + PyObject *mv; + PyObject *result; + Py_buffer *buffer; + Py_ssize_t offset = 0; + + StgDictObject *dict = PyType_stgdict(type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, "abstract class"); + return NULL; + } + + if (!PyArg_ParseTuple(args, "O|n:from_buffer", &obj, &offset)) + return NULL; + + mv = PyMemoryView_FromObject(obj); + if (mv == NULL) + return NULL; + + buffer = PyMemoryView_GET_BUFFER(mv); + + if (buffer->readonly) { + PyErr_SetString(PyExc_TypeError, + "underlying buffer is not writable"); + Py_DECREF(mv); + return NULL; + } + + if (!PyBuffer_IsContiguous(buffer, 'C')) { + PyErr_SetString(PyExc_TypeError, + "underlying buffer is not C contiguous"); + Py_DECREF(mv); + return NULL; + } + + if (offset < 0) { + PyErr_SetString(PyExc_ValueError, + "offset cannot be negative"); + Py_DECREF(mv); + return NULL; + } + + if (dict->size > buffer->len - offset) { + PyErr_Format(PyExc_ValueError, + "Buffer size too small " + "(%zd instead of at least %zd bytes)", + buffer->len, dict->size + offset); + Py_DECREF(mv); + return NULL; + } + + if (PySys_Audit("ctypes.cdata/buffer", "nnn", + (Py_ssize_t)buffer->buf, buffer->len, offset) < 0) { + Py_DECREF(mv); + return NULL; + } + + result = PyCData_AtAddress(type, (char *)buffer->buf + offset); + if (result == NULL) { + Py_DECREF(mv); + return NULL; + } + + if (-1 == KeepRef((CDataObject *)result, -1, mv)) { + Py_DECREF(result); + return NULL; + } + + return result; +} + +PyDoc_STRVAR(from_buffer_copy_doc, +"C.from_buffer_copy(object, offset=0) -> C instance\ncreate a C instance from a readable buffer"); + +static PyObject * +GenericPyCData_new(PyTypeObject *type, PyObject *args, PyObject *kwds); + +static PyObject * +CDataType_from_buffer_copy(PyObject *type, PyObject *args) +{ + Py_buffer buffer; + Py_ssize_t offset = 0; + PyObject *result; + StgDictObject *dict = PyType_stgdict(type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, "abstract class"); + return NULL; + } + + if (!PyArg_ParseTuple(args, "y*|n:from_buffer_copy", &buffer, &offset)) + return NULL; + + if (offset < 0) { + PyErr_SetString(PyExc_ValueError, + "offset cannot be negative"); + PyBuffer_Release(&buffer); + return NULL; + } + + if (dict->size > buffer.len - offset) { + PyErr_Format(PyExc_ValueError, + "Buffer size too small (%zd instead of at least %zd bytes)", + buffer.len, dict->size + offset); + PyBuffer_Release(&buffer); + return NULL; + } + + if (PySys_Audit("ctypes.cdata/buffer", "nnn", + (Py_ssize_t)buffer.buf, buffer.len, offset) < 0) { + PyBuffer_Release(&buffer); + return NULL; + } + + result = GenericPyCData_new((PyTypeObject *)type, NULL, NULL); + if (result != NULL) { + memcpy(((CDataObject *)result)->b_ptr, + (char *)buffer.buf + offset, dict->size); + } + PyBuffer_Release(&buffer); + return result; +} + +PyDoc_STRVAR(in_dll_doc, +"C.in_dll(dll, name) -> C instance\naccess a C instance in a dll"); + +static PyObject * +CDataType_in_dll(PyObject *type, PyObject *args) +{ + PyObject *dll; + char *name; + PyObject *obj; + void *handle; + void *address; + + if (!PyArg_ParseTuple(args, "Os:in_dll", &dll, &name)) + return NULL; + if (PySys_Audit("ctypes.dlsym", "O", args) < 0) { + return NULL; + } + + obj = PyObject_GetAttrString(dll, "_handle"); + if (!obj) + return NULL; + if (!PyLong_Check(obj)) { + PyErr_SetString(PyExc_TypeError, + "the _handle attribute of the second argument must be an integer"); + Py_DECREF(obj); + return NULL; + } + handle = (void *)PyLong_AsVoidPtr(obj); + Py_DECREF(obj); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_ValueError, + "could not convert the _handle attribute to a pointer"); + return NULL; + } + +#ifdef MS_WIN32 + Py_BEGIN_ALLOW_THREADS + address = (void *)GetProcAddress(handle, name); + Py_END_ALLOW_THREADS + if (!address) { + PyErr_Format(PyExc_ValueError, + "symbol '%s' not found", + name); + return NULL; + } +#else + address = (void *)dlsym(handle, name); + if (!address) { +#ifdef __CYGWIN__ +/* dlerror() isn't very helpful on cygwin */ + PyErr_Format(PyExc_ValueError, + "symbol '%s' not found", + name); +#else + PyErr_SetString(PyExc_ValueError, dlerror()); +#endif + return NULL; + } +#endif + return PyCData_AtAddress(type, address); +} + +PyDoc_STRVAR(from_param_doc, +"Convert a Python object into a function call parameter."); + +static PyObject * +CDataType_from_param(PyObject *type, PyObject *value) +{ + PyObject *as_parameter; + int res = PyObject_IsInstance(value, type); + if (res == -1) + return NULL; + if (res) { + return Py_NewRef(value); + } + ctypes_state *st = GLOBAL_STATE(); + if (PyCArg_CheckExact(st, value)) { + PyCArgObject *p = (PyCArgObject *)value; + PyObject *ob = p->obj; + const char *ob_name; + StgDictObject *dict; + dict = PyType_stgdict(type); + + /* If we got a PyCArgObject, we must check if the object packed in it + is an instance of the type's dict->proto */ + if(dict && ob) { + res = PyObject_IsInstance(ob, dict->proto); + if (res == -1) + return NULL; + if (res) { + return Py_NewRef(value); + } + } + ob_name = (ob) ? Py_TYPE(ob)->tp_name : "???"; + PyErr_Format(PyExc_TypeError, + "expected %s instance instead of pointer to %s", + ((PyTypeObject *)type)->tp_name, ob_name); + return NULL; + } + + if (_PyObject_LookupAttr(value, _Py_ID(_as_parameter_), &as_parameter) < 0) { + return NULL; + } + if (as_parameter) { + value = CDataType_from_param(type, as_parameter); + Py_DECREF(as_parameter); + return value; + } + PyErr_Format(PyExc_TypeError, + "expected %s instance instead of %s", + ((PyTypeObject *)type)->tp_name, + Py_TYPE(value)->tp_name); + return NULL; +} + +static PyMethodDef CDataType_methods[] = { + { "from_param", CDataType_from_param, METH_O, from_param_doc }, + { "from_address", CDataType_from_address, METH_O, from_address_doc }, + { "from_buffer", CDataType_from_buffer, METH_VARARGS, from_buffer_doc, }, + { "from_buffer_copy", CDataType_from_buffer_copy, METH_VARARGS, from_buffer_copy_doc, }, + { "in_dll", CDataType_in_dll, METH_VARARGS, in_dll_doc }, + { NULL, NULL }, +}; + +static PyObject * +CDataType_repeat(PyObject *self, Py_ssize_t length) +{ + if (length < 0) + return PyErr_Format(PyExc_ValueError, + "Array length must be >= 0, not %zd", + length); + return PyCArrayType_from_ctype(self, length); +} + +static PySequenceMethods CDataType_as_sequence = { + 0, /* inquiry sq_length; */ + 0, /* binaryfunc sq_concat; */ + CDataType_repeat, /* intargfunc sq_repeat; */ + 0, /* intargfunc sq_item; */ + 0, /* intintargfunc sq_slice; */ + 0, /* intobjargproc sq_ass_item; */ + 0, /* intintobjargproc sq_ass_slice; */ + 0, /* objobjproc sq_contains; */ + + 0, /* binaryfunc sq_inplace_concat; */ + 0, /* intargfunc sq_inplace_repeat; */ +}; + +static int +CDataType_clear(PyTypeObject *self) +{ + StgDictObject *dict = PyType_stgdict((PyObject *)self); + if (dict) + Py_CLEAR(dict->proto); + return PyType_Type.tp_clear((PyObject *)self); +} + +static int +CDataType_traverse(PyTypeObject *self, visitproc visit, void *arg) +{ + StgDictObject *dict = PyType_stgdict((PyObject *)self); + if (dict) + Py_VISIT(dict->proto); + return PyType_Type.tp_traverse((PyObject *)self, visit, arg); +} + +static int +PyCStructType_setattro(PyObject *self, PyObject *key, PyObject *value) +{ + /* XXX Should we disallow deleting _fields_? */ + if (-1 == PyType_Type.tp_setattro(self, key, value)) + return -1; + + if (value && PyUnicode_Check(key) && + _PyUnicode_EqualToASCIIString(key, "_fields_")) + return PyCStructUnionType_update_stgdict(self, value, 1); + return 0; +} + + +static int +UnionType_setattro(PyObject *self, PyObject *key, PyObject *value) +{ + /* XXX Should we disallow deleting _fields_? */ + if (-1 == PyObject_GenericSetAttr(self, key, value)) + return -1; + + if (PyUnicode_Check(key) && + _PyUnicode_EqualToASCIIString(key, "_fields_")) + return PyCStructUnionType_update_stgdict(self, value, 0); + return 0; +} + + +PyTypeObject PyCStructType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.PyCStructType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + PyCStructType_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + PyDoc_STR("metatype for the CData Objects"), /* tp_doc */ + (traverseproc)CDataType_traverse, /* tp_traverse */ + (inquiry)CDataType_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + CDataType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCStructType_new, /* tp_new */ + 0, /* tp_free */ +}; + +static PyTypeObject UnionType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.UnionType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + UnionType_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + PyDoc_STR("metatype for the CData Objects"), /* tp_doc */ + (traverseproc)CDataType_traverse, /* tp_traverse */ + (inquiry)CDataType_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + CDataType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + UnionType_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/******************************************************************/ + +/* + +The PyCPointerType_Type metaclass must ensure that the subclass of Pointer can be +created. It must check for a _type_ attribute in the class. Since are no +runtime created properties, a CField is probably *not* needed ? + +class IntPointer(Pointer): + _type_ = "i" + +The PyCPointer_Type provides the functionality: a contents method/property, a +size property/method, and the sequence protocol. + +*/ + +static int +PyCPointerType_SetProto(StgDictObject *stgdict, PyObject *proto) +{ + if (!proto || !PyType_Check(proto)) { + PyErr_SetString(PyExc_TypeError, + "_type_ must be a type"); + return -1; + } + if (!PyType_stgdict(proto)) { + PyErr_SetString(PyExc_TypeError, + "_type_ must have storage info"); + return -1; + } + Py_INCREF(proto); + Py_XSETREF(stgdict->proto, proto); + return 0; +} + +static PyCArgObject * +PyCPointerType_paramfunc(CDataObject *self) +{ + PyCArgObject *parg; + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + + parg->tag = 'P'; + parg->pffi_type = &ffi_type_pointer; + parg->obj = Py_NewRef(self); + parg->value.p = *(void **)self->b_ptr; + return parg; +} + +static PyObject * +PyCPointerType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyTypeObject *result; + StgDictObject *stgdict; + PyObject *proto; + PyObject *typedict; + + + typedict = PyTuple_GetItem(args, 2); + if (!typedict) + return NULL; +/* + stgdict items size, align, length contain info about pointers itself, + stgdict->proto has info about the pointed to type! +*/ + stgdict = (StgDictObject *)_PyObject_CallNoArgs( + (PyObject *)&PyCStgDict_Type); + if (!stgdict) + return NULL; + stgdict->size = sizeof(void *); + stgdict->align = _ctypes_get_fielddesc("P")->pffi_type->alignment; + stgdict->length = 1; + stgdict->ffi_type_pointer = ffi_type_pointer; + stgdict->paramfunc = PyCPointerType_paramfunc; + stgdict->flags |= TYPEFLAG_ISPOINTER; + + proto = PyDict_GetItemWithError(typedict, _Py_ID(_type_)); /* Borrowed ref */ + if (proto) { + StgDictObject *itemdict; + const char *current_format; + if (-1 == PyCPointerType_SetProto(stgdict, proto)) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + itemdict = PyType_stgdict(proto); + /* PyCPointerType_SetProto has verified proto has a stgdict. */ + assert(itemdict); + /* If itemdict->format is NULL, then this is a pointer to an + incomplete type. We create a generic format string + 'pointer to bytes' in this case. XXX Better would be to + fix the format string later... + */ + current_format = itemdict->format ? itemdict->format : "B"; + if (itemdict->shape != NULL) { + /* pointer to an array: the shape needs to be prefixed */ + stgdict->format = _ctypes_alloc_format_string_with_shape( + itemdict->ndim, itemdict->shape, "&", current_format); + } else { + stgdict->format = _ctypes_alloc_format_string("&", current_format); + } + if (stgdict->format == NULL) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + } + else if (PyErr_Occurred()) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + + /* create the new instance (which is a class, + since we are a metatype!) */ + result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds); + if (result == NULL) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + + /* replace the class dict by our updated spam dict */ + if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) { + Py_DECREF(result); + Py_DECREF((PyObject *)stgdict); + return NULL; + } + set_graalpy_tp_dict(result, stgdict); // GraalPy change: do not use Py_SETREF + + return (PyObject *)result; +} + + +static PyObject * +PyCPointerType_set_type(PyTypeObject *self, PyObject *type) +{ + StgDictObject *dict; + + + dict = PyType_stgdict((PyObject *)self); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + + if (-1 == PyCPointerType_SetProto(dict, type)) + return NULL; + + if (-1 == PyDict_SetItem((PyObject *)dict, _Py_ID(_type_), type)) + return NULL; + + Py_RETURN_NONE; +} + +static PyObject *_byref(PyObject *); + +static PyObject * +PyCPointerType_from_param(PyObject *type, PyObject *value) +{ + StgDictObject *typedict; + + if (value == Py_None) { + /* ConvParam will convert to a NULL pointer later */ + return Py_NewRef(value); + } + + typedict = PyType_stgdict(type); + if (!typedict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + + /* If we expect POINTER(), but receive a instance, accept + it by calling byref(). + */ + switch (PyObject_IsInstance(value, typedict->proto)) { + case 1: + Py_INCREF(value); /* _byref steals a refcount */ + return _byref(value); + case -1: + return NULL; + default: + break; + } + + if (PointerObject_Check(value) || ArrayObject_Check(value)) { + /* Array instances are also pointers when + the item types are the same. + */ + StgDictObject *v = PyObject_stgdict(value); + assert(v); /* Cannot be NULL for pointer or array objects */ + int ret = PyObject_IsSubclass(v->proto, typedict->proto); + if (ret < 0) { + return NULL; + } + if (ret) { + return Py_NewRef(value); + } + } + return CDataType_from_param(type, value); +} + +static PyMethodDef PyCPointerType_methods[] = { + { "from_address", CDataType_from_address, METH_O, from_address_doc }, + { "from_buffer", CDataType_from_buffer, METH_VARARGS, from_buffer_doc, }, + { "from_buffer_copy", CDataType_from_buffer_copy, METH_VARARGS, from_buffer_copy_doc, }, + { "in_dll", CDataType_in_dll, METH_VARARGS, in_dll_doc}, + { "from_param", (PyCFunction)PyCPointerType_from_param, METH_O, from_param_doc}, + { "set_type", (PyCFunction)PyCPointerType_set_type, METH_O }, + { NULL, NULL }, +}; + +PyTypeObject PyCPointerType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.PyCPointerType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + PyDoc_STR("metatype for the Pointer Objects"), /* tp_doc */ + (traverseproc)CDataType_traverse, /* tp_traverse */ + (inquiry)CDataType_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PyCPointerType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCPointerType_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/******************************************************************/ +/* + PyCArrayType_Type +*/ +/* + PyCArrayType_new ensures that the new Array subclass created has a _length_ + attribute, and a _type_ attribute. +*/ + +static int +CharArray_set_raw(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored)) +{ + char *ptr; + Py_ssize_t size; + Py_buffer view; + + if (value == NULL) { + PyErr_SetString(PyExc_AttributeError, "cannot delete attribute"); + return -1; + } + if (PyObject_GetBuffer(value, &view, PyBUF_SIMPLE) < 0) + return -1; + size = view.len; + ptr = view.buf; + if (size > self->b_size) { + PyErr_SetString(PyExc_ValueError, + "byte string too long"); + goto fail; + } + + memcpy(self->b_ptr, ptr, size); + + PyBuffer_Release(&view); + return 0; + fail: + PyBuffer_Release(&view); + return -1; +} + +static PyObject * +CharArray_get_raw(CDataObject *self, void *Py_UNUSED(ignored)) +{ + return PyBytes_FromStringAndSize(self->b_ptr, self->b_size); +} + +static PyObject * +CharArray_get_value(CDataObject *self, void *Py_UNUSED(ignored)) +{ + Py_ssize_t i; + char *ptr = self->b_ptr; + for (i = 0; i < self->b_size; ++i) + if (*ptr++ == '\0') + break; + return PyBytes_FromStringAndSize(self->b_ptr, i); +} + +static int +CharArray_set_value(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored)) +{ + const char *ptr; + Py_ssize_t size; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "can't delete attribute"); + return -1; + } + + if (!PyBytes_Check(value)) { + PyErr_Format(PyExc_TypeError, + "bytes expected instead of %s instance", + Py_TYPE(value)->tp_name); + return -1; + } else + Py_INCREF(value); + size = PyBytes_GET_SIZE(value); + if (size > self->b_size) { + PyErr_SetString(PyExc_ValueError, + "byte string too long"); + Py_DECREF(value); + return -1; + } + + ptr = PyBytes_AS_STRING(value); + memcpy(self->b_ptr, ptr, size); + if (size < self->b_size) + self->b_ptr[size] = '\0'; + Py_DECREF(value); + + return 0; +} + +static PyGetSetDef CharArray_getsets[] = { + { "raw", (getter)CharArray_get_raw, (setter)CharArray_set_raw, + "value", NULL }, + { "value", (getter)CharArray_get_value, (setter)CharArray_set_value, + "string value"}, + { NULL, NULL } +}; + +static PyObject * +WCharArray_get_value(CDataObject *self, void *Py_UNUSED(ignored)) +{ + Py_ssize_t i; + wchar_t *ptr = (wchar_t *)self->b_ptr; + for (i = 0; i < self->b_size/(Py_ssize_t)sizeof(wchar_t); ++i) + if (*ptr++ == (wchar_t)0) + break; + return PyUnicode_FromWideChar((wchar_t *)self->b_ptr, i); +} + +static int +WCharArray_set_value(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored)) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "can't delete attribute"); + return -1; + } + if (!PyUnicode_Check(value)) { + PyErr_Format(PyExc_TypeError, + "unicode string expected instead of %s instance", + Py_TYPE(value)->tp_name); + return -1; + } + + Py_ssize_t size = self->b_size / sizeof(wchar_t); + Py_ssize_t len = PyUnicode_AsWideChar(value, NULL, 0); + if (len < 0) { + return -1; + } + // PyUnicode_AsWideChar() returns number of wchars including trailing null byte, + // when it is called with NULL. + assert(len > 0); + if (len - 1 > size) { + PyErr_SetString(PyExc_ValueError, "string too long"); + return -1; + } + if (PyUnicode_AsWideChar(value, (wchar_t *)self->b_ptr, size) < 0) { + return -1; + } + return 0; +} + +static PyGetSetDef WCharArray_getsets[] = { + { "value", (getter)WCharArray_get_value, (setter)WCharArray_set_value, + "string value"}, + { NULL, NULL } +}; + +/* + The next function is copied from Python's typeobject.c. + + It is used to attach getsets to a type *after* it + has been created: Arrays of characters have additional getsets to treat them + as strings. + */ + +static int +add_getset(PyTypeObject *type, PyGetSetDef *gsp) +{ + PyObject *dict = type->tp_dict; + for (; gsp->name != NULL; gsp++) { + PyObject *descr; + descr = PyDescr_NewGetSet(type, gsp); + if (descr == NULL) + return -1; + if (PyDict_SetItemString(dict, gsp->name, descr) < 0) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + } + return 0; +} + +static PyCArgObject * +PyCArrayType_paramfunc(CDataObject *self) +{ + PyCArgObject *p = PyCArgObject_new(); + if (p == NULL) + return NULL; + p->tag = 'P'; + p->pffi_type = &ffi_type_pointer; + p->value.p = (char *)self->b_ptr; + p->obj = Py_NewRef(self); + return p; +} + +static PyObject * +PyCArrayType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyTypeObject *result; + StgDictObject *stgdict; + StgDictObject *itemdict; + PyObject *length_attr, *type_attr; + Py_ssize_t length; + Py_ssize_t itemsize, itemalign; + + /* create the new instance (which is a class, + since we are a metatype!) */ + result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds); + if (result == NULL) + return NULL; + + /* Initialize these variables to NULL so that we can simplify error + handling by using Py_XDECREF. */ + stgdict = NULL; + type_attr = NULL; + + if (_PyObject_LookupAttr((PyObject *)result, _Py_ID(_length_), &length_attr) < 0) { + goto error; + } + if (!length_attr) { + PyErr_SetString(PyExc_AttributeError, + "class must define a '_length_' attribute"); + goto error; + } + + if (!PyLong_Check(length_attr)) { + Py_DECREF(length_attr); + PyErr_SetString(PyExc_TypeError, + "The '_length_' attribute must be an integer"); + goto error; + } + + if (_PyLong_Sign(length_attr) == -1) { + Py_DECREF(length_attr); + PyErr_SetString(PyExc_ValueError, + "The '_length_' attribute must not be negative"); + goto error; + } + + length = PyLong_AsSsize_t(length_attr); + Py_DECREF(length_attr); + if (length == -1 && PyErr_Occurred()) { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) { + PyErr_SetString(PyExc_OverflowError, + "The '_length_' attribute is too large"); + } + goto error; + } + + if (_PyObject_LookupAttr((PyObject *)result, _Py_ID(_type_), &type_attr) < 0) { + goto error; + } + if (!type_attr) { + PyErr_SetString(PyExc_AttributeError, + "class must define a '_type_' attribute"); + goto error; + } + + stgdict = (StgDictObject *)_PyObject_CallNoArgs( + (PyObject *)&PyCStgDict_Type); + if (!stgdict) + goto error; + + itemdict = PyType_stgdict(type_attr); + if (!itemdict) { + PyErr_SetString(PyExc_TypeError, + "_type_ must have storage info"); + goto error; + } + + assert(itemdict->format); + stgdict->format = _ctypes_alloc_format_string(NULL, itemdict->format); + if (stgdict->format == NULL) + goto error; + stgdict->ndim = itemdict->ndim + 1; + stgdict->shape = PyMem_Malloc(sizeof(Py_ssize_t) * stgdict->ndim); + if (stgdict->shape == NULL) { + PyErr_NoMemory(); + goto error; + } + stgdict->shape[0] = length; + if (stgdict->ndim > 1) { + memmove(&stgdict->shape[1], itemdict->shape, + sizeof(Py_ssize_t) * (stgdict->ndim - 1)); + } + + itemsize = itemdict->size; + if (itemsize != 0 && length > PY_SSIZE_T_MAX / itemsize) { + PyErr_SetString(PyExc_OverflowError, + "array too large"); + goto error; + } + + itemalign = itemdict->align; + + if (itemdict->flags & (TYPEFLAG_ISPOINTER | TYPEFLAG_HASPOINTER)) + stgdict->flags |= TYPEFLAG_HASPOINTER; + + stgdict->size = itemsize * length; + stgdict->align = itemalign; + stgdict->length = length; + stgdict->proto = type_attr; + type_attr = NULL; + + stgdict->paramfunc = &PyCArrayType_paramfunc; + + /* Arrays are passed as pointers to function calls. */ + stgdict->ffi_type_pointer = ffi_type_pointer; + + /* replace the class dict by our updated spam dict */ + if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) + goto error; + set_graalpy_tp_dict(result, stgdict); // GraalPy change: do not use Py_SETREF + stgdict = NULL; + + /* Special case for character arrays. + A permanent annoyance: char arrays are also strings! + */ + if (itemdict->getfunc == _ctypes_get_fielddesc("c")->getfunc) { + if (-1 == add_getset(result, CharArray_getsets)) + goto error; + } + else if (itemdict->getfunc == _ctypes_get_fielddesc("u")->getfunc) { + if (-1 == add_getset(result, WCharArray_getsets)) + goto error; + } + + return (PyObject *)result; +error: + Py_XDECREF((PyObject*)stgdict); + Py_XDECREF(type_attr); + Py_DECREF(result); + return NULL; +} + +PyTypeObject PyCArrayType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.PyCArrayType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("metatype for the Array Objects"), /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + CDataType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCArrayType_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/******************************************************************/ +/* + PyCSimpleType_Type +*/ +/* + +PyCSimpleType_new ensures that the new Simple_Type subclass created has a valid +_type_ attribute. + +*/ + +static const char SIMPLE_TYPE_CHARS[] = "cbBhHiIlLdfuzZqQPXOv?g"; + +static PyObject * +c_wchar_p_from_param(PyObject *type, PyObject *value) +{ + PyObject *as_parameter; + int res; + if (value == Py_None) { + Py_RETURN_NONE; + } + if (PyUnicode_Check(value)) { + PyCArgObject *parg; + struct fielddesc *fd = _ctypes_get_fielddesc("Z"); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'Z'; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj == NULL) { + Py_DECREF(parg); + return NULL; + } + return (PyObject *)parg; + } + res = PyObject_IsInstance(value, type); + if (res == -1) + return NULL; + if (res) { + return Py_NewRef(value); + } + if (ArrayObject_Check(value) || PointerObject_Check(value)) { + /* c_wchar array instance or pointer(c_wchar(...)) */ + StgDictObject *dt = PyObject_stgdict(value); + StgDictObject *dict; + assert(dt); /* Cannot be NULL for pointer or array objects */ + dict = dt && dt->proto ? PyType_stgdict(dt->proto) : NULL; + if (dict && (dict->setfunc == _ctypes_get_fielddesc("u")->setfunc)) { + return Py_NewRef(value); + } + } + ctypes_state *st = GLOBAL_STATE(); + if (PyCArg_CheckExact(st, value)) { + /* byref(c_char(...)) */ + PyCArgObject *a = (PyCArgObject *)value; + StgDictObject *dict = PyObject_stgdict(a->obj); + if (dict && (dict->setfunc == _ctypes_get_fielddesc("u")->setfunc)) { + return Py_NewRef(value); + } + } + + if (_PyObject_LookupAttr(value, _Py_ID(_as_parameter_), &as_parameter) < 0) { + return NULL; + } + if (as_parameter) { + value = c_wchar_p_from_param(type, as_parameter); + Py_DECREF(as_parameter); + return value; + } + /* XXX better message */ + PyErr_SetString(PyExc_TypeError, + "wrong type"); + return NULL; +} + +static PyObject * +c_char_p_from_param(PyObject *type, PyObject *value) +{ + PyObject *as_parameter; + int res; + if (value == Py_None) { + Py_RETURN_NONE; + } + if (PyBytes_Check(value)) { + PyCArgObject *parg; + struct fielddesc *fd = _ctypes_get_fielddesc("z"); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'z'; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj == NULL) { + Py_DECREF(parg); + return NULL; + } + return (PyObject *)parg; + } + res = PyObject_IsInstance(value, type); + if (res == -1) + return NULL; + if (res) { + return Py_NewRef(value); + } + if (ArrayObject_Check(value) || PointerObject_Check(value)) { + /* c_char array instance or pointer(c_char(...)) */ + StgDictObject *dt = PyObject_stgdict(value); + StgDictObject *dict; + assert(dt); /* Cannot be NULL for pointer or array objects */ + dict = dt && dt->proto ? PyType_stgdict(dt->proto) : NULL; + if (dict && (dict->setfunc == _ctypes_get_fielddesc("c")->setfunc)) { + return Py_NewRef(value); + } + } + ctypes_state *st = GLOBAL_STATE(); + if (PyCArg_CheckExact(st, value)) { + /* byref(c_char(...)) */ + PyCArgObject *a = (PyCArgObject *)value; + StgDictObject *dict = PyObject_stgdict(a->obj); + if (dict && (dict->setfunc == _ctypes_get_fielddesc("c")->setfunc)) { + return Py_NewRef(value); + } + } + + if (_PyObject_LookupAttr(value, _Py_ID(_as_parameter_), &as_parameter) < 0) { + return NULL; + } + if (as_parameter) { + value = c_char_p_from_param(type, as_parameter); + Py_DECREF(as_parameter); + return value; + } + /* XXX better message */ + PyErr_SetString(PyExc_TypeError, + "wrong type"); + return NULL; +} + +static PyObject * +c_void_p_from_param(PyObject *type, PyObject *value) +{ + StgDictObject *stgd; + PyObject *as_parameter; + int res; + +/* None */ + if (value == Py_None) { + Py_RETURN_NONE; + } + /* Should probably allow buffer interface as well */ +/* int, long */ + if (PyLong_Check(value)) { + PyCArgObject *parg; + struct fielddesc *fd = _ctypes_get_fielddesc("P"); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'P'; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj == NULL) { + Py_DECREF(parg); + return NULL; + } + return (PyObject *)parg; + } + /* XXX struni: remove later */ +/* bytes */ + if (PyBytes_Check(value)) { + PyCArgObject *parg; + struct fielddesc *fd = _ctypes_get_fielddesc("z"); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'z'; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj == NULL) { + Py_DECREF(parg); + return NULL; + } + return (PyObject *)parg; + } +/* unicode */ + if (PyUnicode_Check(value)) { + PyCArgObject *parg; + struct fielddesc *fd = _ctypes_get_fielddesc("Z"); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'Z'; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj == NULL) { + Py_DECREF(parg); + return NULL; + } + return (PyObject *)parg; + } +/* c_void_p instance (or subclass) */ + res = PyObject_IsInstance(value, type); + if (res == -1) + return NULL; + if (res) { + /* c_void_p instances */ + return Py_NewRef(value); + } +/* ctypes array or pointer instance */ + if (ArrayObject_Check(value) || PointerObject_Check(value)) { + /* Any array or pointer is accepted */ + return Py_NewRef(value); + } +/* byref(...) */ + ctypes_state *st = GLOBAL_STATE(); + if (PyCArg_CheckExact(st, value)) { + /* byref(c_xxx()) */ + PyCArgObject *a = (PyCArgObject *)value; + if (a->tag == 'P') { + return Py_NewRef(value); + } + } +/* function pointer */ + if (PyCFuncPtrObject_Check(value)) { + PyCArgObject *parg; + PyCFuncPtrObject *func; + func = (PyCFuncPtrObject *)value; + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'P'; + Py_INCREF(value); + parg->value.p = *(void **)func->b_ptr; + parg->obj = value; + return (PyObject *)parg; + } +/* c_char_p, c_wchar_p */ + stgd = PyObject_stgdict(value); + if (stgd && CDataObject_Check(value) && stgd->proto && PyUnicode_Check(stgd->proto)) { + PyCArgObject *parg; + + switch (PyUnicode_AsUTF8(stgd->proto)[0]) { + case 'z': /* c_char_p */ + case 'Z': /* c_wchar_p */ + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + parg->pffi_type = &ffi_type_pointer; + parg->tag = 'Z'; + parg->obj = Py_NewRef(value); + /* Remember: b_ptr points to where the pointer is stored! */ + parg->value.p = *(void **)(((CDataObject *)value)->b_ptr); + return (PyObject *)parg; + } + } + + if (_PyObject_LookupAttr(value, _Py_ID(_as_parameter_), &as_parameter) < 0) { + return NULL; + } + if (as_parameter) { + value = c_void_p_from_param(type, as_parameter); + Py_DECREF(as_parameter); + return value; + } + /* XXX better message */ + PyErr_SetString(PyExc_TypeError, + "wrong type"); + return NULL; +} + +static PyMethodDef c_void_p_method = { "from_param", c_void_p_from_param, METH_O }; +static PyMethodDef c_char_p_method = { "from_param", c_char_p_from_param, METH_O }; +static PyMethodDef c_wchar_p_method = { "from_param", c_wchar_p_from_param, METH_O }; + +static PyObject *CreateSwappedType(PyTypeObject *type, PyObject *args, PyObject *kwds, + PyObject *proto, struct fielddesc *fmt) +{ + PyTypeObject *result; + StgDictObject *stgdict; + PyObject *name = PyTuple_GET_ITEM(args, 0); + PyObject *newname; + PyObject *swapped_args; + static PyObject *suffix; + Py_ssize_t i; + + swapped_args = PyTuple_New(PyTuple_GET_SIZE(args)); + if (!swapped_args) + return NULL; + + if (suffix == NULL) +#ifdef WORDS_BIGENDIAN + suffix = PyUnicode_InternFromString("_le"); +#else + suffix = PyUnicode_InternFromString("_be"); +#endif + if (suffix == NULL) { + Py_DECREF(swapped_args); + return NULL; + } + + newname = PyUnicode_Concat(name, suffix); + if (newname == NULL) { + Py_DECREF(swapped_args); + return NULL; + } + + PyTuple_SET_ITEM(swapped_args, 0, newname); + for (i=1; iffi_type_pointer = *fmt->pffi_type; + stgdict->align = fmt->pffi_type->alignment; + stgdict->length = 0; + stgdict->size = fmt->pffi_type->size; + stgdict->setfunc = fmt->setfunc_swapped; + stgdict->getfunc = fmt->getfunc_swapped; + + stgdict->proto = Py_NewRef(proto); + + /* replace the class dict by our updated spam dict */ + if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) { + Py_DECREF(result); + Py_DECREF((PyObject *)stgdict); + return NULL; + } + set_graalpy_tp_dict(result, stgdict); // GraalPy change: do not use Py_SETREF + + return (PyObject *)result; +} + +static PyCArgObject * +PyCSimpleType_paramfunc(CDataObject *self) +{ + StgDictObject *dict; + const char *fmt; + PyCArgObject *parg; + struct fielddesc *fd; + + dict = PyObject_stgdict((PyObject *)self); + assert(dict); /* Cannot be NULL for CDataObject instances */ + fmt = PyUnicode_AsUTF8(dict->proto); + assert(fmt); + + fd = _ctypes_get_fielddesc(fmt); + assert(fd); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + + parg->tag = fmt[0]; + parg->pffi_type = fd->pffi_type; + parg->obj = Py_NewRef(self); + memcpy(&parg->value, self->b_ptr, self->b_size); + return parg; +} + +static PyObject * +PyCSimpleType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyTypeObject *result; + StgDictObject *stgdict; + PyObject *proto; + const char *proto_str; + Py_ssize_t proto_len; + PyMethodDef *ml; + struct fielddesc *fmt; + + /* create the new instance (which is a class, + since we are a metatype!) */ + result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds); + if (result == NULL) + return NULL; + + if (_PyObject_LookupAttr((PyObject *)result, _Py_ID(_type_), &proto) < 0) { + return NULL; + } + if (!proto) { + PyErr_SetString(PyExc_AttributeError, + "class must define a '_type_' attribute"); + error: + Py_XDECREF(proto); + Py_DECREF(result); + return NULL; + } + if (PyUnicode_Check(proto)) { + proto_str = PyUnicode_AsUTF8AndSize(proto, &proto_len); + if (!proto_str) + goto error; + } else { + PyErr_SetString(PyExc_TypeError, + "class must define a '_type_' string attribute"); + goto error; + } + if (proto_len != 1) { + PyErr_SetString(PyExc_ValueError, + "class must define a '_type_' attribute " + "which must be a string of length 1"); + goto error; + } + if (!strchr(SIMPLE_TYPE_CHARS, *proto_str)) { + PyErr_Format(PyExc_AttributeError, + "class must define a '_type_' attribute which must be\n" + "a single character string containing one of '%s'.", + SIMPLE_TYPE_CHARS); + goto error; + } + fmt = _ctypes_get_fielddesc(proto_str); + if (fmt == NULL) { + PyErr_Format(PyExc_ValueError, + "_type_ '%s' not supported", proto_str); + goto error; + } + + stgdict = (StgDictObject *)_PyObject_CallNoArgs( + (PyObject *)&PyCStgDict_Type); + if (!stgdict) + goto error; + + stgdict->ffi_type_pointer = *fmt->pffi_type; + stgdict->align = fmt->pffi_type->alignment; + stgdict->length = 0; + stgdict->size = fmt->pffi_type->size; + stgdict->setfunc = fmt->setfunc; + stgdict->getfunc = fmt->getfunc; +#ifdef WORDS_BIGENDIAN + stgdict->format = _ctypes_alloc_format_string_for_type(proto_str[0], 1); +#else + stgdict->format = _ctypes_alloc_format_string_for_type(proto_str[0], 0); +#endif + if (stgdict->format == NULL) { + Py_DECREF(result); + Py_DECREF(proto); + Py_DECREF((PyObject *)stgdict); + return NULL; + } + + stgdict->paramfunc = PyCSimpleType_paramfunc; +/* + if (result->tp_base != &Simple_Type) { + stgdict->setfunc = NULL; + stgdict->getfunc = NULL; + } +*/ + + /* This consumes the refcount on proto which we have */ + stgdict->proto = proto; + + /* replace the class dict by our updated spam dict */ + if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) { + Py_DECREF(result); + Py_DECREF((PyObject *)stgdict); + return NULL; + } + set_graalpy_tp_dict(result, stgdict); // GraalPy change: do not use Py_SETREF + + /* Install from_param class methods in ctypes base classes. + Overrides the PyCSimpleType_from_param generic method. + */ + if (result->tp_base == &Simple_Type) { + switch (*proto_str) { + case 'z': /* c_char_p */ + ml = &c_char_p_method; + stgdict->flags |= TYPEFLAG_ISPOINTER; + break; + case 'Z': /* c_wchar_p */ + ml = &c_wchar_p_method; + stgdict->flags |= TYPEFLAG_ISPOINTER; + break; + case 'P': /* c_void_p */ + ml = &c_void_p_method; + stgdict->flags |= TYPEFLAG_ISPOINTER; + break; + case 's': + case 'X': + case 'O': + ml = NULL; + stgdict->flags |= TYPEFLAG_ISPOINTER; + break; + default: + ml = NULL; + break; + } + + if (ml) { + PyObject *meth; + int x; + meth = PyDescr_NewClassMethod(result, ml); + if (!meth) { + Py_DECREF(result); + return NULL; + } + PyObject *name = PyUnicode_FromString(ml->ml_name); + if (name == NULL) { + Py_DECREF(meth); + Py_DECREF(result); + return NULL; + } + PyUnicode_InternInPlace(&name); + x = PyDict_SetItem(result->tp_dict, name, meth); + Py_DECREF(name); + Py_DECREF(meth); + if (x == -1) { + Py_DECREF(result); + return NULL; + } + } + } + + if (type == &PyCSimpleType_Type && fmt->setfunc_swapped && fmt->getfunc_swapped) { + PyObject *swapped = CreateSwappedType(type, args, kwds, + proto, fmt); + StgDictObject *sw_dict; + if (swapped == NULL) { + Py_DECREF(result); + return NULL; + } + sw_dict = PyType_stgdict(swapped); +#ifdef WORDS_BIGENDIAN + PyObject_SetAttrString((PyObject *)result, "__ctype_le__", swapped); + PyObject_SetAttrString((PyObject *)result, "__ctype_be__", (PyObject *)result); + PyObject_SetAttrString(swapped, "__ctype_be__", (PyObject *)result); + PyObject_SetAttrString(swapped, "__ctype_le__", swapped); + /* We are creating the type for the OTHER endian */ + sw_dict->format = _ctypes_alloc_format_string("<", stgdict->format+1); +#else + PyObject_SetAttrString((PyObject *)result, "__ctype_be__", swapped); + PyObject_SetAttrString((PyObject *)result, "__ctype_le__", (PyObject *)result); + PyObject_SetAttrString(swapped, "__ctype_le__", (PyObject *)result); + PyObject_SetAttrString(swapped, "__ctype_be__", swapped); + /* We are creating the type for the OTHER endian */ + sw_dict->format = _ctypes_alloc_format_string(">", stgdict->format+1); +#endif + Py_DECREF(swapped); + if (PyErr_Occurred()) { + Py_DECREF(result); + return NULL; + } + }; + + return (PyObject *)result; +} + +/* + * This is a *class method*. + * Convert a parameter into something that ConvParam can handle. + */ +static PyObject * +PyCSimpleType_from_param(PyObject *type, PyObject *value) +{ + StgDictObject *dict; + const char *fmt; + PyCArgObject *parg; + struct fielddesc *fd; + PyObject *as_parameter; + int res; + + /* If the value is already an instance of the requested type, + we can use it as is */ + res = PyObject_IsInstance(value, type); + if (res == -1) + return NULL; + if (res) { + return Py_NewRef(value); + } + + dict = PyType_stgdict(type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + + /* I think we can rely on this being a one-character string */ + fmt = PyUnicode_AsUTF8(dict->proto); + assert(fmt); + + fd = _ctypes_get_fielddesc(fmt); + assert(fd); + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + + parg->tag = fmt[0]; + parg->pffi_type = fd->pffi_type; + parg->obj = fd->setfunc(&parg->value, value, 0); + if (parg->obj) + return (PyObject *)parg; + PyObject *exc = PyErr_GetRaisedException(); + Py_DECREF(parg); + + if (_PyObject_LookupAttr(value, _Py_ID(_as_parameter_), &as_parameter) < 0) { + Py_XDECREF(exc); + return NULL; + } + if (as_parameter) { + if (_Py_EnterRecursiveCall(" while processing _as_parameter_")) { + Py_DECREF(as_parameter); + Py_XDECREF(exc); + return NULL; + } + value = PyCSimpleType_from_param(type, as_parameter); + _Py_LeaveRecursiveCall(); + Py_DECREF(as_parameter); + Py_XDECREF(exc); + return value; + } + if (exc) { + PyErr_SetRaisedException(exc); + } + else { + PyErr_SetString(PyExc_TypeError, "wrong type"); + } + return NULL; +} + +static PyMethodDef PyCSimpleType_methods[] = { + { "from_param", PyCSimpleType_from_param, METH_O, from_param_doc }, + { "from_address", CDataType_from_address, METH_O, from_address_doc }, + { "from_buffer", CDataType_from_buffer, METH_VARARGS, from_buffer_doc, }, + { "from_buffer_copy", CDataType_from_buffer_copy, METH_VARARGS, from_buffer_copy_doc, }, + { "in_dll", CDataType_in_dll, METH_VARARGS, in_dll_doc}, + { NULL, NULL }, +}; + +PyTypeObject PyCSimpleType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.PyCSimpleType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("metatype for the PyCSimpleType Objects"), /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PyCSimpleType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCSimpleType_new, /* tp_new */ + 0, /* tp_free */ +}; + +/******************************************************************/ +/* + PyCFuncPtrType_Type + */ + +static PyObject * +converters_from_argtypes(PyObject *ob) +{ + PyObject *converters; + Py_ssize_t i; + + ob = PySequence_Tuple(ob); /* new reference */ + if (!ob) { + PyErr_SetString(PyExc_TypeError, + "_argtypes_ must be a sequence of types"); + return NULL; + } + + Py_ssize_t nArgs = PyTuple_GET_SIZE(ob); + if (nArgs > CTYPES_MAX_ARGCOUNT) { + Py_DECREF(ob); + PyErr_Format(PyExc_ArgError, + "_argtypes_ has too many arguments (%zi), maximum is %i", + nArgs, CTYPES_MAX_ARGCOUNT); + return NULL; + } + + converters = PyTuple_New(nArgs); + if (!converters) { + Py_DECREF(ob); + return NULL; + } + + /* I have to check if this is correct. Using c_char, which has a size + of 1, will be assumed to be pushed as only one byte! + Aren't these promoted to integers by the C compiler and pushed as 4 bytes? + */ + + for (i = 0; i < nArgs; ++i) { + PyObject *cnv; + PyObject *tp = PyTuple_GET_ITEM(ob, i); +/* + * The following checks, relating to bpo-16575 and bpo-16576, have been + * disabled. The reason is that, although there is a definite problem with + * how libffi handles unions (https://github.com/libffi/libffi/issues/33), + * there are numerous libraries which pass structures containing unions + * by values - especially on Windows but examples also exist on Linux + * (https://bugs.python.org/msg359834). + * + * It may not be possible to get proper support for unions and bitfields + * until support is forthcoming in libffi, but for now, adding the checks + * has caused problems in otherwise-working software, which suggests it + * is better to disable the checks. + * + * Although specific examples reported relate specifically to unions and + * not bitfields, the bitfields check is also being disabled as a + * precaution. + + StgDictObject *stgdict = PyType_stgdict(tp); + + if (stgdict != NULL) { + if (stgdict->flags & TYPEFLAG_HASUNION) { + Py_DECREF(converters); + Py_DECREF(ob); + if (!PyErr_Occurred()) { + PyErr_Format(PyExc_TypeError, + "item %zd in _argtypes_ passes a union by " + "value, which is unsupported.", + i + 1); + } + return NULL; + } + if (stgdict->flags & TYPEFLAG_HASBITFIELD) { + Py_DECREF(converters); + Py_DECREF(ob); + if (!PyErr_Occurred()) { + PyErr_Format(PyExc_TypeError, + "item %zd in _argtypes_ passes a struct/" + "union with a bitfield by value, which is " + "unsupported.", + i + 1); + } + return NULL; + } + } + */ + + if (_PyObject_LookupAttr(tp, _Py_ID(from_param), &cnv) <= 0) { + Py_DECREF(converters); + Py_DECREF(ob); + if (!PyErr_Occurred()) { + PyErr_Format(PyExc_TypeError, + "item %zd in _argtypes_ has no from_param method", + i+1); + } + return NULL; + } + PyTuple_SET_ITEM(converters, i, cnv); + } + Py_DECREF(ob); + return converters; +} + +static int +make_funcptrtype_dict(StgDictObject *stgdict) +{ + PyObject *ob; + PyObject *converters = NULL; + + stgdict->align = _ctypes_get_fielddesc("P")->pffi_type->alignment; + stgdict->length = 1; + stgdict->size = sizeof(void *); + stgdict->setfunc = NULL; + stgdict->getfunc = NULL; + stgdict->ffi_type_pointer = ffi_type_pointer; + + ob = PyDict_GetItemWithError((PyObject *)stgdict, _Py_ID(_flags_)); + if (!ob || !PyLong_Check(ob)) { + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "class must define _flags_ which must be an integer"); + } + return -1; + } + stgdict->flags = PyLong_AsUnsignedLongMask(ob) | TYPEFLAG_ISPOINTER; + + /* _argtypes_ is optional... */ + ob = PyDict_GetItemWithError((PyObject *)stgdict, _Py_ID(_argtypes_)); + if (ob) { + converters = converters_from_argtypes(ob); + if (!converters) + return -1; + stgdict->argtypes = Py_NewRef(ob); + stgdict->converters = converters; + } + else if (PyErr_Occurred()) { + return -1; + } + + ob = PyDict_GetItemWithError((PyObject *)stgdict, _Py_ID(_restype_)); + if (ob) { + if (ob != Py_None && !PyType_stgdict(ob) && !PyCallable_Check(ob)) { + PyErr_SetString(PyExc_TypeError, + "_restype_ must be a type, a callable, or None"); + return -1; + } + stgdict->restype = Py_NewRef(ob); + if (_PyObject_LookupAttr(ob, _Py_ID(_check_retval_), + &stgdict->checker) < 0) + { + return -1; + } + } + else if (PyErr_Occurred()) { + return -1; + } +/* XXX later, maybe. + ob = _PyDict_GetItemIdWithError((PyObject *)stgdict, &PyId__errcheck_); + if (ob) { + if (!PyCallable_Check(ob)) { + PyErr_SetString(PyExc_TypeError, + "_errcheck_ must be callable"); + return -1; + } + stgdict->errcheck = Py_NewRef(ob); + } + else if (PyErr_Occurred()) { + return -1; + } +*/ + return 0; +} + +static PyCArgObject * +PyCFuncPtrType_paramfunc(CDataObject *self) +{ + PyCArgObject *parg; + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + + parg->tag = 'P'; + parg->pffi_type = &ffi_type_pointer; + parg->obj = Py_NewRef(self); + parg->value.p = *(void **)self->b_ptr; + return parg; +} + +static PyObject * +PyCFuncPtrType_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyTypeObject *result; + StgDictObject *stgdict; + + stgdict = (StgDictObject *)_PyObject_CallNoArgs( + (PyObject *)&PyCStgDict_Type); + if (!stgdict) + return NULL; + + stgdict->paramfunc = PyCFuncPtrType_paramfunc; + /* We do NOT expose the function signature in the format string. It + is impossible, generally, because the only requirement for the + argtypes items is that they have a .from_param method - we do not + know the types of the arguments (although, in practice, most + argtypes would be a ctypes type). + */ + stgdict->format = _ctypes_alloc_format_string(NULL, "X{}"); + if (stgdict->format == NULL) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + stgdict->flags |= TYPEFLAG_ISPOINTER; + + /* create the new instance (which is a class, + since we are a metatype!) */ + result = (PyTypeObject *)PyType_Type.tp_new(type, args, kwds); + if (result == NULL) { + Py_DECREF((PyObject *)stgdict); + return NULL; + } + + /* replace the class dict by our updated storage dict */ + if (-1 == PyDict_Update((PyObject *)stgdict, result->tp_dict)) { + Py_DECREF(result); + Py_DECREF((PyObject *)stgdict); + return NULL; + } + set_graalpy_tp_dict(result, stgdict); // GraalPy change: do not use Py_SETREF + + if (-1 == make_funcptrtype_dict(stgdict)) { + Py_DECREF(result); + return NULL; + } + + return (PyObject *)result; +} + +PyTypeObject PyCFuncPtrType_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.PyCFuncPtrType", /* tp_name */ + 0, /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &CDataType_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */ + PyDoc_STR("metatype for C function pointers"), /* tp_doc */ + (traverseproc)CDataType_traverse, /* tp_traverse */ + (inquiry)CDataType_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + CDataType_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCFuncPtrType_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/***************************************************************** + * Code to keep needed objects alive + */ + +static CDataObject * +PyCData_GetContainer(CDataObject *self) +{ + while (self->b_base) + self = self->b_base; + if (self->b_objects == NULL) { + if (self->b_length) { + self->b_objects = PyDict_New(); + if (self->b_objects == NULL) + return NULL; + } else { + self->b_objects = Py_NewRef(Py_None); + } + } + return self; +} + +static PyObject * +GetKeepedObjects(CDataObject *target) +{ + CDataObject *container; + container = PyCData_GetContainer(target); + if (container == NULL) + return NULL; + return container->b_objects; +} + +static PyObject * +unique_key(CDataObject *target, Py_ssize_t index) +{ + char string[256]; + char *cp = string; + size_t bytes_left; + + Py_BUILD_ASSERT(sizeof(string) - 1 > sizeof(Py_ssize_t) * 2); + cp += sprintf(cp, "%x", Py_SAFE_DOWNCAST(index, Py_ssize_t, int)); + while (target->b_base) { + bytes_left = sizeof(string) - (cp - string) - 1; + /* Hex format needs 2 characters per byte */ + if (bytes_left < sizeof(Py_ssize_t) * 2) { + PyErr_SetString(PyExc_ValueError, + "ctypes object structure too deep"); + return NULL; + } + cp += sprintf(cp, ":%x", Py_SAFE_DOWNCAST(target->b_index, Py_ssize_t, int)); + target = target->b_base; + } + return PyUnicode_FromStringAndSize(string, cp-string); +} + +/* + * Keep a reference to 'keep' in the 'target', at index 'index'. + * + * If 'keep' is None, do nothing. + * + * Otherwise create a dictionary (if it does not yet exist) id the root + * objects 'b_objects' item, which will store the 'keep' object under a unique + * key. + * + * The unique_key helper travels the target's b_base pointer down to the root, + * building a string containing hex-formatted indexes found during traversal, + * separated by colons. + * + * The index tuple is used as a key into the root object's b_objects dict. + * + * Note: This function steals a refcount of the third argument, even if it + * fails! + */ +static int +KeepRef(CDataObject *target, Py_ssize_t index, PyObject *keep) +{ + int result; + CDataObject *ob; + PyObject *key; + +/* Optimization: no need to store None */ + if (keep == Py_None) { + Py_DECREF(Py_None); + return 0; + } + ob = PyCData_GetContainer(target); + if (ob == NULL) { + Py_DECREF(keep); + return -1; + } + if (ob->b_objects == NULL || !PyDict_CheckExact(ob->b_objects)) { + Py_XSETREF(ob->b_objects, keep); /* refcount consumed */ + return 0; + } + key = unique_key(target, index); + if (key == NULL) { + Py_DECREF(keep); + return -1; + } + result = PyDict_SetItem(ob->b_objects, key, keep); + Py_DECREF(key); + Py_DECREF(keep); + return result; +} + +/******************************************************************/ +/* + PyCData_Type + */ +static int +PyCData_traverse(CDataObject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->b_objects); + Py_VISIT((PyObject *)self->b_base); + return 0; +} + +static int +PyCData_clear(CDataObject *self) +{ + Py_CLEAR(self->b_objects); + if ((self->b_needsfree) + && _CDataObject_HasExternalBuffer(self)) + PyMem_Free(self->b_ptr); + self->b_ptr = NULL; + Py_CLEAR(self->b_base); + return 0; +} + +static void +PyCData_dealloc(PyObject *self) +{ + PyCData_clear((CDataObject *)self); + Py_TYPE(self)->tp_free(self); +} + +static PyMemberDef PyCData_members[] = { + { "_b_base_", T_OBJECT, + offsetof(CDataObject, b_base), READONLY, + "the base object" }, + { "_b_needsfree_", T_INT, + offsetof(CDataObject, b_needsfree), READONLY, + "whether the object owns the memory or not" }, + { "_objects", T_OBJECT, + offsetof(CDataObject, b_objects), READONLY, + "internal objects tree (NEVER CHANGE THIS OBJECT!)"}, + { NULL }, +}; + +/* Find the innermost type of an array type, returning a borrowed reference */ +static PyObject * +PyCData_item_type(PyObject *type) +{ + if (PyCArrayTypeObject_Check(type)) { + StgDictObject *stg_dict; + PyObject *elem_type; + + /* asserts used here as these are all guaranteed by construction */ + stg_dict = PyType_stgdict(type); + assert(stg_dict); + elem_type = stg_dict->proto; + assert(elem_type); + return PyCData_item_type(elem_type); + } + else { + return type; + } +} + +static int +PyCData_NewGetBuffer(PyObject *myself, Py_buffer *view, int flags) +{ + CDataObject *self = (CDataObject *)myself; + StgDictObject *dict = PyObject_stgdict(myself); + PyObject *item_type = PyCData_item_type((PyObject*)Py_TYPE(myself)); + StgDictObject *item_dict = PyType_stgdict(item_type); + + if (view == NULL) return 0; + + view->buf = self->b_ptr; + view->obj = Py_NewRef(myself); + view->len = self->b_size; + view->readonly = 0; + /* use default format character if not set */ + view->format = dict->format ? dict->format : "B"; + view->ndim = dict->ndim; + view->shape = dict->shape; + view->itemsize = item_dict->size; + view->strides = NULL; + view->suboffsets = NULL; + view->internal = NULL; + return 0; +} + +static PyBufferProcs PyCData_as_buffer = { + PyCData_NewGetBuffer, + NULL, +}; + +/* + * CData objects are mutable, so they cannot be hashable! + */ +static Py_hash_t +PyCData_nohash(PyObject *self) +{ + PyErr_SetString(PyExc_TypeError, "unhashable type"); + return -1; +} + +static PyObject * +PyCData_reduce(PyObject *myself, PyObject *args) +{ + CDataObject *self = (CDataObject *)myself; + + if (PyObject_stgdict(myself)->flags & (TYPEFLAG_ISPOINTER|TYPEFLAG_HASPOINTER)) { + PyErr_SetString(PyExc_ValueError, + "ctypes objects containing pointers cannot be pickled"); + return NULL; + } + PyObject *dict = PyObject_GetAttrString(myself, "__dict__"); + if (dict == NULL) { + return NULL; + } + return Py_BuildValue("O(O(NN))", _unpickle, Py_TYPE(myself), dict, + PyBytes_FromStringAndSize(self->b_ptr, self->b_size)); +} + +static PyObject * +PyCData_setstate(PyObject *myself, PyObject *args) +{ + void *data; + Py_ssize_t len; + int res; + PyObject *dict, *mydict; + CDataObject *self = (CDataObject *)myself; + if (!PyArg_ParseTuple(args, "O!s#", + &PyDict_Type, &dict, &data, &len)) + { + return NULL; + } + if (len > self->b_size) + len = self->b_size; + memmove(self->b_ptr, data, len); + mydict = PyObject_GetAttrString(myself, "__dict__"); + if (mydict == NULL) { + return NULL; + } + if (!PyDict_Check(mydict)) { + PyErr_Format(PyExc_TypeError, + "%.200s.__dict__ must be a dictionary, not %.200s", + Py_TYPE(myself)->tp_name, Py_TYPE(mydict)->tp_name); + Py_DECREF(mydict); + return NULL; + } + res = PyDict_Update(mydict, dict); + Py_DECREF(mydict); + if (res == -1) + return NULL; + Py_RETURN_NONE; +} + +/* + * default __ctypes_from_outparam__ method returns self. + */ +static PyObject * +PyCData_from_outparam(PyObject *self, PyObject *args) +{ + return Py_NewRef(self); +} + +static PyMethodDef PyCData_methods[] = { + { "__ctypes_from_outparam__", PyCData_from_outparam, METH_NOARGS, }, + { "__reduce__", PyCData_reduce, METH_NOARGS, }, + { "__setstate__", PyCData_setstate, METH_VARARGS, }, + { NULL, NULL }, +}; + +PyTypeObject PyCData_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes._CData", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + PyCData_dealloc, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + PyCData_nohash, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("XXX to be provided"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PyCData_methods, /* tp_methods */ + PyCData_members, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ +}; + +static int PyCData_MallocBuffer(CDataObject *obj, StgDictObject *dict) +{ + if ((size_t)dict->size <= sizeof(obj->b_value)) { + /* No need to call malloc, can use the default buffer */ + obj->b_ptr = (char *)&obj->b_value; + /* The b_needsfree flag does not mean that we actually did + call PyMem_Malloc to allocate the memory block; instead it + means we are the *owner* of the memory and are responsible + for freeing resources associated with the memory. This is + also the reason that b_needsfree is exposed to Python. + */ + obj->b_needsfree = 1; + } else { + /* In python 2.4, and ctypes 0.9.6, the malloc call took about + 33% of the creation time for c_int(). + */ + obj->b_ptr = (char *)PyMem_Malloc(dict->size); + if (obj->b_ptr == NULL) { + PyErr_NoMemory(); + return -1; + } + obj->b_needsfree = 1; + memset(obj->b_ptr, 0, dict->size); + } + obj->b_size = dict->size; + return 0; +} + +PyObject * +PyCData_FromBaseObj(PyObject *type, PyObject *base, Py_ssize_t index, char *adr) +{ + CDataObject *cmem; + StgDictObject *dict; + + assert(PyType_Check(type)); + dict = PyType_stgdict(type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + dict->flags |= DICTFLAG_FINAL; + cmem = (CDataObject *)((PyTypeObject *)type)->tp_alloc((PyTypeObject *)type, 0); + if (cmem == NULL) + return NULL; + assert(CDataObject_Check(cmem)); + + cmem->b_length = dict->length; + cmem->b_size = dict->size; + if (base) { /* use base's buffer */ + assert(CDataObject_Check(base)); + cmem->b_ptr = adr; + cmem->b_needsfree = 0; + cmem->b_base = (CDataObject *)Py_NewRef(base); + cmem->b_index = index; + } else { /* copy contents of adr */ + if (-1 == PyCData_MallocBuffer(cmem, dict)) { + Py_DECREF(cmem); + return NULL; + } + memcpy(cmem->b_ptr, adr, dict->size); + cmem->b_index = index; + } + return (PyObject *)cmem; +} + +/* + Box a memory block into a CData instance. +*/ +PyObject * +PyCData_AtAddress(PyObject *type, void *buf) +{ + CDataObject *pd; + StgDictObject *dict; + + if (PySys_Audit("ctypes.cdata", "n", (Py_ssize_t)buf) < 0) { + return NULL; + } + + assert(PyType_Check(type)); + dict = PyType_stgdict(type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + dict->flags |= DICTFLAG_FINAL; + + pd = (CDataObject *)((PyTypeObject *)type)->tp_alloc((PyTypeObject *)type, 0); + if (!pd) + return NULL; + assert(CDataObject_Check(pd)); + pd->b_ptr = (char *)buf; + pd->b_length = dict->length; + pd->b_size = dict->size; + return (PyObject *)pd; +} + +/* + This function returns TRUE for c_int, c_void_p, and these kind of + classes. FALSE otherwise FALSE also for subclasses of c_int and + such. +*/ +int _ctypes_simple_instance(PyObject *obj) +{ + PyTypeObject *type = (PyTypeObject *)obj; + + if (PyCSimpleTypeObject_Check(type)) + return type->tp_base != &Simple_Type; + return 0; +} + +PyObject * +PyCData_get(PyObject *type, GETFUNC getfunc, PyObject *src, + Py_ssize_t index, Py_ssize_t size, char *adr) +{ + StgDictObject *dict; + if (getfunc) + return getfunc(adr, size); + assert(type); + dict = PyType_stgdict(type); + if (dict && dict->getfunc && !_ctypes_simple_instance(type)) + return dict->getfunc(adr, size); + return PyCData_FromBaseObj(type, src, index, adr); +} + +/* + Helper function for PyCData_set below. +*/ +static PyObject * +_PyCData_set(CDataObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value, + Py_ssize_t size, char *ptr) +{ + CDataObject *src; + int err; + + if (setfunc) + return setfunc(ptr, value, size); + + if (!CDataObject_Check(value)) { + StgDictObject *dict = PyType_stgdict(type); + if (dict && dict->setfunc) + return dict->setfunc(ptr, value, size); + /* + If value is a tuple, we try to call the type with the tuple + and use the result! + */ + assert(PyType_Check(type)); + if (PyTuple_Check(value)) { + PyObject *ob; + PyObject *result; + ob = PyObject_CallObject(type, value); + if (ob == NULL) { + _ctypes_extend_error(PyExc_RuntimeError, "(%s) ", + ((PyTypeObject *)type)->tp_name); + return NULL; + } + result = _PyCData_set(dst, type, setfunc, ob, + size, ptr); + Py_DECREF(ob); + return result; + } else if (value == Py_None && PyCPointerTypeObject_Check(type)) { + *(void **)ptr = NULL; + Py_RETURN_NONE; + } else { + PyErr_Format(PyExc_TypeError, + "expected %s instance, got %s", + ((PyTypeObject *)type)->tp_name, + Py_TYPE(value)->tp_name); + return NULL; + } + } + src = (CDataObject *)value; + + err = PyObject_IsInstance(value, type); + if (err == -1) + return NULL; + if (err) { + memcpy(ptr, + src->b_ptr, + size); + + if (PyCPointerTypeObject_Check(type)) { + /* XXX */ + } + + value = GetKeepedObjects(src); + if (value == NULL) + return NULL; + + return Py_NewRef(value); + } + + if (PyCPointerTypeObject_Check(type) + && ArrayObject_Check(value)) { + StgDictObject *p1, *p2; + PyObject *keep; + p1 = PyObject_stgdict(value); + assert(p1); /* Cannot be NULL for array instances */ + p2 = PyType_stgdict(type); + assert(p2); /* Cannot be NULL for pointer types */ + + if (p1->proto != p2->proto) { + PyErr_Format(PyExc_TypeError, + "incompatible types, %s instance instead of %s instance", + Py_TYPE(value)->tp_name, + ((PyTypeObject *)type)->tp_name); + return NULL; + } + *(void **)ptr = src->b_ptr; + + keep = GetKeepedObjects(src); + if (keep == NULL) + return NULL; + + /* + We are assigning an array object to a field which represents + a pointer. This has the same effect as converting an array + into a pointer. So, again, we have to keep the whole object + pointed to (which is the array in this case) alive, and not + only it's object list. So we create a tuple, containing + b_objects list PLUS the array itself, and return that! + */ + return PyTuple_Pack(2, keep, value); + } + PyErr_Format(PyExc_TypeError, + "incompatible types, %s instance instead of %s instance", + Py_TYPE(value)->tp_name, + ((PyTypeObject *)type)->tp_name); + return NULL; +} + +/* + * Set a slice in object 'dst', which has the type 'type', + * to the value 'value'. + */ +int +PyCData_set(PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value, + Py_ssize_t index, Py_ssize_t size, char *ptr) +{ + CDataObject *mem = (CDataObject *)dst; + PyObject *result; + + if (!CDataObject_Check(dst)) { + PyErr_SetString(PyExc_TypeError, + "not a ctype instance"); + return -1; + } + + result = _PyCData_set(mem, type, setfunc, value, + size, ptr); + if (result == NULL) + return -1; + + /* KeepRef steals a refcount from it's last argument */ + /* If KeepRef fails, we are stumped. The dst memory block has already + been changed */ + return KeepRef(mem, index, result); +} + + +/******************************************************************/ +static PyObject * +GenericPyCData_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + CDataObject *obj; + StgDictObject *dict; + + dict = PyType_stgdict((PyObject *)type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return NULL; + } + dict->flags |= DICTFLAG_FINAL; + + obj = (CDataObject *)type->tp_alloc(type, 0); + if (!obj) + return NULL; + + obj->b_base = NULL; + obj->b_index = 0; + obj->b_objects = NULL; + obj->b_length = dict->length; + + if (-1 == PyCData_MallocBuffer(obj, dict)) { + Py_DECREF(obj); + return NULL; + } + return (PyObject *)obj; +} +/*****************************************************************/ +/* + PyCFuncPtr_Type +*/ + +static int +PyCFuncPtr_set_errcheck(PyCFuncPtrObject *self, PyObject *ob, void *Py_UNUSED(ignored)) +{ + if (ob && !PyCallable_Check(ob)) { + PyErr_SetString(PyExc_TypeError, + "the errcheck attribute must be callable"); + return -1; + } + Py_XINCREF(ob); + Py_XSETREF(self->errcheck, ob); + return 0; +} + +static PyObject * +PyCFuncPtr_get_errcheck(PyCFuncPtrObject *self, void *Py_UNUSED(ignored)) +{ + if (self->errcheck) { + return Py_NewRef(self->errcheck); + } + Py_RETURN_NONE; +} + +static int +PyCFuncPtr_set_restype(PyCFuncPtrObject *self, PyObject *ob, void *Py_UNUSED(ignored)) +{ + PyObject *checker, *oldchecker; + if (ob == NULL) { + oldchecker = self->checker; + self->checker = NULL; + Py_CLEAR(self->restype); + Py_XDECREF(oldchecker); + return 0; + } + if (ob != Py_None && !PyType_stgdict(ob) && !PyCallable_Check(ob)) { + PyErr_SetString(PyExc_TypeError, + "restype must be a type, a callable, or None"); + return -1; + } + if (_PyObject_LookupAttr(ob, _Py_ID(_check_retval_), &checker) < 0) { + return -1; + } + oldchecker = self->checker; + self->checker = checker; + Py_INCREF(ob); + Py_XSETREF(self->restype, ob); + Py_XDECREF(oldchecker); + return 0; +} + +static PyObject * +PyCFuncPtr_get_restype(PyCFuncPtrObject *self, void *Py_UNUSED(ignored)) +{ + StgDictObject *dict; + if (self->restype) { + return Py_NewRef(self->restype); + } + dict = PyObject_stgdict((PyObject *)self); + assert(dict); /* Cannot be NULL for PyCFuncPtrObject instances */ + if (dict->restype) { + return Py_NewRef(dict->restype); + } else { + Py_RETURN_NONE; + } +} + +static int +PyCFuncPtr_set_argtypes(PyCFuncPtrObject *self, PyObject *ob, void *Py_UNUSED(ignored)) +{ + PyObject *converters; + + if (ob == NULL || ob == Py_None) { + Py_CLEAR(self->converters); + Py_CLEAR(self->argtypes); + } else { + converters = converters_from_argtypes(ob); + if (!converters) + return -1; + Py_XSETREF(self->converters, converters); + Py_INCREF(ob); + Py_XSETREF(self->argtypes, ob); + } + return 0; +} + +static PyObject * +PyCFuncPtr_get_argtypes(PyCFuncPtrObject *self, void *Py_UNUSED(ignored)) +{ + StgDictObject *dict; + if (self->argtypes) { + return Py_NewRef(self->argtypes); + } + dict = PyObject_stgdict((PyObject *)self); + assert(dict); /* Cannot be NULL for PyCFuncPtrObject instances */ + if (dict->argtypes) { + return Py_NewRef(dict->argtypes); + } else { + Py_RETURN_NONE; + } +} + +static PyGetSetDef PyCFuncPtr_getsets[] = { + { "errcheck", (getter)PyCFuncPtr_get_errcheck, (setter)PyCFuncPtr_set_errcheck, + "a function to check for errors", NULL }, + { "restype", (getter)PyCFuncPtr_get_restype, (setter)PyCFuncPtr_set_restype, + "specify the result type", NULL }, + { "argtypes", (getter)PyCFuncPtr_get_argtypes, + (setter)PyCFuncPtr_set_argtypes, + "specify the argument types", NULL }, + { NULL, NULL } +}; + +#ifdef MS_WIN32 +static PPROC FindAddress(void *handle, const char *name, PyObject *type) +{ + PPROC address; +#ifdef MS_WIN64 + /* win64 has no stdcall calling conv, so it should + also not have the name mangling of it. + */ + Py_BEGIN_ALLOW_THREADS + address = (PPROC)GetProcAddress(handle, name); + Py_END_ALLOW_THREADS + return address; +#else + char *mangled_name; + int i; + StgDictObject *dict; + + Py_BEGIN_ALLOW_THREADS + address = (PPROC)GetProcAddress(handle, name); + Py_END_ALLOW_THREADS + if (address) + return address; + if (((size_t)name & ~0xFFFF) == 0) { + return NULL; + } + + dict = PyType_stgdict((PyObject *)type); + /* It should not happen that dict is NULL, but better be safe */ + if (dict==NULL || dict->flags & FUNCFLAG_CDECL) + return address; + + /* for stdcall, try mangled names: + funcname -> _funcname@ + where n is 0, 4, 8, 12, ..., 128 + */ + mangled_name = alloca(strlen(name) + 1 + 1 + 1 + 3); /* \0 _ @ %d */ + if (!mangled_name) + return NULL; + for (i = 0; i < 32; ++i) { + sprintf(mangled_name, "_%s@%d", name, i*4); + Py_BEGIN_ALLOW_THREADS + address = (PPROC)GetProcAddress(handle, mangled_name); + Py_END_ALLOW_THREADS + if (address) + return address; + } + return NULL; +#endif +} +#endif + +/* Return 1 if usable, 0 else and exception set. */ +static int +_check_outarg_type(PyObject *arg, Py_ssize_t index) +{ + StgDictObject *dict; + + if (PyCPointerTypeObject_Check(arg)) + return 1; + + if (PyCArrayTypeObject_Check(arg)) + return 1; + + dict = PyType_stgdict(arg); + if (dict + /* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */ + && PyUnicode_Check(dict->proto) +/* We only allow c_void_p, c_char_p and c_wchar_p as a simple output parameter type */ + && (strchr("PzZ", PyUnicode_AsUTF8(dict->proto)[0]))) { + return 1; + } + + PyErr_Format(PyExc_TypeError, + "'out' parameter %d must be a pointer type, not %s", + Py_SAFE_DOWNCAST(index, Py_ssize_t, int), + PyType_Check(arg) ? + ((PyTypeObject *)arg)->tp_name : + Py_TYPE(arg)->tp_name); + return 0; +} + +/* Returns 1 on success, 0 on error */ +static int +_validate_paramflags(PyTypeObject *type, PyObject *paramflags) +{ + Py_ssize_t i, len; + StgDictObject *dict; + PyObject *argtypes; + + dict = PyType_stgdict((PyObject *)type); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "abstract class"); + return 0; + } + argtypes = dict->argtypes; + + if (paramflags == NULL || dict->argtypes == NULL) + return 1; + + if (!PyTuple_Check(paramflags)) { + PyErr_SetString(PyExc_TypeError, + "paramflags must be a tuple or None"); + return 0; + } + + len = PyTuple_GET_SIZE(paramflags); + if (len != PyTuple_GET_SIZE(dict->argtypes)) { + PyErr_SetString(PyExc_ValueError, + "paramflags must have the same length as argtypes"); + return 0; + } + + for (i = 0; i < len; ++i) { + PyObject *item = PyTuple_GET_ITEM(paramflags, i); + int flag; + PyObject *name = Py_None; + PyObject *defval; + PyObject *typ; + if (!PyArg_ParseTuple(item, "i|OO", &flag, &name, &defval) || + !(name == Py_None || PyUnicode_Check(name))) + { + PyErr_SetString(PyExc_TypeError, + "paramflags must be a sequence of (int [,string [,value]]) tuples"); + return 0; + } + typ = PyTuple_GET_ITEM(argtypes, i); + switch (flag & (PARAMFLAG_FIN | PARAMFLAG_FOUT | PARAMFLAG_FLCID)) { + case 0: + case PARAMFLAG_FIN: + case PARAMFLAG_FIN | PARAMFLAG_FLCID: + case PARAMFLAG_FIN | PARAMFLAG_FOUT: + break; + case PARAMFLAG_FOUT: + if (!_check_outarg_type(typ, i+1)) + return 0; + break; + default: + PyErr_Format(PyExc_TypeError, + "paramflag value %d not supported", + flag); + return 0; + } + } + return 1; +} + +static int +_get_name(PyObject *obj, const char **pname) +{ +#ifdef MS_WIN32 + if (PyLong_Check(obj)) { + /* We have to use MAKEINTRESOURCEA for Windows CE. + Works on Windows as well, of course. + */ + *pname = MAKEINTRESOURCEA(PyLong_AsUnsignedLongMask(obj) & 0xFFFF); + return 1; + } +#endif + if (PyBytes_Check(obj)) { + *pname = PyBytes_AS_STRING(obj); + return *pname ? 1 : 0; + } + if (PyUnicode_Check(obj)) { + *pname = PyUnicode_AsUTF8(obj); + return *pname ? 1 : 0; + } + PyErr_SetString(PyExc_TypeError, + "function name must be string, bytes object or integer"); + return 0; +} + + +static PyObject * +PyCFuncPtr_FromDll(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + const char *name; + int (* address)(void); + PyObject *ftuple; + PyObject *dll; + PyObject *obj; + PyCFuncPtrObject *self; + void *handle; + PyObject *paramflags = NULL; + + if (!PyArg_ParseTuple(args, "O|O", &ftuple, ¶mflags)) + return NULL; + if (paramflags == Py_None) + paramflags = NULL; + + ftuple = PySequence_Tuple(ftuple); + if (!ftuple) + /* Here ftuple is a borrowed reference */ + return NULL; + + if (!PyArg_ParseTuple(ftuple, "O&O;illegal func_spec argument", + _get_name, &name, &dll)) + { + Py_DECREF(ftuple); + return NULL; + } + +#ifdef MS_WIN32 + if (PySys_Audit("ctypes.dlsym", + ((uintptr_t)name & ~0xFFFF) ? "Os" : "On", + dll, name) < 0) { + Py_DECREF(ftuple); + return NULL; + } +#else + if (PySys_Audit("ctypes.dlsym", "Os", dll, name) < 0) { + Py_DECREF(ftuple); + return NULL; + } +#endif + + obj = PyObject_GetAttrString(dll, "_handle"); + if (!obj) { + Py_DECREF(ftuple); + return NULL; + } + if (!PyLong_Check(obj)) { + PyErr_SetString(PyExc_TypeError, + "the _handle attribute of the second argument must be an integer"); + Py_DECREF(ftuple); + Py_DECREF(obj); + return NULL; + } + handle = (void *)PyLong_AsVoidPtr(obj); + Py_DECREF(obj); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_ValueError, + "could not convert the _handle attribute to a pointer"); + Py_DECREF(ftuple); + return NULL; + } + +#ifdef MS_WIN32 + address = FindAddress(handle, name, (PyObject *)type); + if (!address) { + if (!IS_INTRESOURCE(name)) + PyErr_Format(PyExc_AttributeError, + "function '%s' not found", + name); + else + PyErr_Format(PyExc_AttributeError, + "function ordinal %d not found", + (WORD)(size_t)name); + Py_DECREF(ftuple); + return NULL; + } +#else + address = (PPROC)dlsym(handle, name); + if (!address) { +#ifdef __CYGWIN__ +/* dlerror() isn't very helpful on cygwin */ + PyErr_Format(PyExc_AttributeError, + "function '%s' not found", + name); +#else + PyErr_SetString(PyExc_AttributeError, dlerror()); +#endif + Py_DECREF(ftuple); + return NULL; + } +#endif + if (!_validate_paramflags(type, paramflags)) { + Py_DECREF(ftuple); + return NULL; + } + + self = (PyCFuncPtrObject *)GenericPyCData_new(type, args, kwds); + if (!self) { + Py_DECREF(ftuple); + return NULL; + } + + self->paramflags = Py_XNewRef(paramflags); + + *(void **)self->b_ptr = address; + Py_INCREF(dll); + Py_DECREF(ftuple); + if (-1 == KeepRef((CDataObject *)self, 0, dll)) { + Py_DECREF((PyObject *)self); + return NULL; + } + + self->callable = Py_NewRef(self); + return (PyObject *)self; +} + +#ifdef MS_WIN32 +static PyObject * +PyCFuncPtr_FromVtblIndex(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyCFuncPtrObject *self; + int index; + char *name = NULL; + PyObject *paramflags = NULL; + GUID *iid = NULL; + Py_ssize_t iid_len = 0; + + if (!PyArg_ParseTuple(args, "is|Oz#", &index, &name, ¶mflags, &iid, &iid_len)) + return NULL; + if (paramflags == Py_None) + paramflags = NULL; + + if (!_validate_paramflags(type, paramflags)) + return NULL; + + self = (PyCFuncPtrObject *)GenericPyCData_new(type, args, kwds); + self->index = index + 0x1000; + self->paramflags = Py_XNewRef(paramflags); + if (iid_len == sizeof(GUID)) + self->iid = iid; + return (PyObject *)self; +} +#endif + +/* + PyCFuncPtr_new accepts different argument lists in addition to the standard + _basespec_ keyword arg: + + one argument form + "i" - function address + "O" - must be a callable, creates a C callable function + + two or more argument forms (the third argument is a paramflags tuple) + "(sO)|..." - (function name, dll object (with an integer handle)), paramflags + "(iO)|..." - (function ordinal, dll object (with an integer handle)), paramflags + "is|..." - vtable index, method name, creates callable calling COM vtbl +*/ +static PyObject * +PyCFuncPtr_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyCFuncPtrObject *self; + PyObject *callable; + StgDictObject *dict; + CThunkObject *thunk; + + if (PyTuple_GET_SIZE(args) == 0) + return GenericPyCData_new(type, args, kwds); + + if (1 <= PyTuple_GET_SIZE(args) && PyTuple_Check(PyTuple_GET_ITEM(args, 0))) + return PyCFuncPtr_FromDll(type, args, kwds); + +#ifdef MS_WIN32 + if (2 <= PyTuple_GET_SIZE(args) && PyLong_Check(PyTuple_GET_ITEM(args, 0))) + return PyCFuncPtr_FromVtblIndex(type, args, kwds); +#endif + + if (1 == PyTuple_GET_SIZE(args) + && (PyLong_Check(PyTuple_GET_ITEM(args, 0)))) { + CDataObject *ob; + void *ptr = PyLong_AsVoidPtr(PyTuple_GET_ITEM(args, 0)); + if (ptr == NULL && PyErr_Occurred()) + return NULL; + ob = (CDataObject *)GenericPyCData_new(type, args, kwds); + if (ob == NULL) + return NULL; + *(void **)ob->b_ptr = ptr; + return (PyObject *)ob; + } + + if (!PyArg_ParseTuple(args, "O", &callable)) + return NULL; + if (!PyCallable_Check(callable)) { + PyErr_SetString(PyExc_TypeError, + "argument must be callable or integer function address"); + return NULL; + } + + /* XXX XXX This would allow passing additional options. For COM + method *implementations*, we would probably want different + behaviour than in 'normal' callback functions: return a HRESULT if + an exception occurs in the callback, and print the traceback not + only on the console, but also to OutputDebugString() or something + like that. + */ +/* + if (kwds && _PyDict_GetItemIdWithError(kwds, &PyId_options)) { + ... + } + else if (PyErr_Occurred()) { + return NULL; + } +*/ + + dict = PyType_stgdict((PyObject *)type); + /* XXXX Fails if we do: 'PyCFuncPtr(lambda x: x)' */ + if (!dict || !dict->argtypes) { + PyErr_SetString(PyExc_TypeError, + "cannot construct instance of this class:" + " no argtypes"); + return NULL; + } + + thunk = _ctypes_alloc_callback(callable, + dict->argtypes, + dict->restype, + dict->flags); + if (!thunk) + return NULL; + + self = (PyCFuncPtrObject *)GenericPyCData_new(type, args, kwds); + if (self == NULL) { + Py_DECREF(thunk); + return NULL; + } + + self->callable = Py_NewRef(callable); + + self->thunk = thunk; + *(void **)self->b_ptr = (void *)thunk->pcl_exec; + + Py_INCREF((PyObject *)thunk); /* for KeepRef */ + if (-1 == KeepRef((CDataObject *)self, 0, (PyObject *)thunk)) { + Py_DECREF((PyObject *)self); + return NULL; + } + return (PyObject *)self; +} + + +/* + _byref consumes a refcount to its argument +*/ +static PyObject * +_byref(PyObject *obj) +{ + PyCArgObject *parg; + if (!CDataObject_Check(obj)) { + PyErr_SetString(PyExc_TypeError, + "expected CData instance"); + return NULL; + } + + parg = PyCArgObject_new(); + if (parg == NULL) { + Py_DECREF(obj); + return NULL; + } + + parg->tag = 'P'; + parg->pffi_type = &ffi_type_pointer; + parg->obj = obj; + parg->value.p = ((CDataObject *)obj)->b_ptr; + return (PyObject *)parg; +} + +static PyObject * +_get_arg(int *pindex, PyObject *name, PyObject *defval, PyObject *inargs, PyObject *kwds) +{ + PyObject *v; + + if (*pindex < PyTuple_GET_SIZE(inargs)) { + v = PyTuple_GET_ITEM(inargs, *pindex); + ++*pindex; + return Py_NewRef(v); + } + if (kwds && name) { + v = PyDict_GetItemWithError(kwds, name); + if (v) { + ++*pindex; + return Py_NewRef(v); + } + else if (PyErr_Occurred()) { + return NULL; + } + } + if (defval) { + return Py_NewRef(defval); + } + /* we can't currently emit a better error message */ + if (name) + PyErr_Format(PyExc_TypeError, + "required argument '%S' missing", name); + else + PyErr_Format(PyExc_TypeError, + "not enough arguments"); + return NULL; +} + +/* + This function implements higher level functionality plus the ability to call + functions with keyword arguments by looking at parameter flags. parameter + flags is a tuple of 1, 2 or 3-tuples. The first entry in each is an integer + specifying the direction of the data transfer for this parameter - 'in', + 'out' or 'inout' (zero means the same as 'in'). The second entry is the + parameter name, and the third is the default value if the parameter is + missing in the function call. + + This function builds and returns a new tuple 'callargs' which contains the + parameters to use in the call. Items on this tuple are copied from the + 'inargs' tuple for 'in' and 'in, out' parameters, and constructed from the + 'argtypes' tuple for 'out' parameters. It also calculates numretvals which + is the number of return values for the function, outmask/inoutmask are + bitmasks containing indexes into the callargs tuple specifying which + parameters have to be returned. _build_result builds the return value of the + function. +*/ +static PyObject * +_build_callargs(PyCFuncPtrObject *self, PyObject *argtypes, + PyObject *inargs, PyObject *kwds, + int *poutmask, int *pinoutmask, unsigned int *pnumretvals) +{ + PyObject *paramflags = self->paramflags; + PyObject *callargs; + StgDictObject *dict; + Py_ssize_t i, len; + int inargs_index = 0; + /* It's a little bit difficult to determine how many arguments the + function call requires/accepts. For simplicity, we count the consumed + args and compare this to the number of supplied args. */ + Py_ssize_t actual_args; + + *poutmask = 0; + *pinoutmask = 0; + *pnumretvals = 0; + + /* Trivial cases, where we either return inargs itself, or a slice of it. */ + if (argtypes == NULL || paramflags == NULL || PyTuple_GET_SIZE(argtypes) == 0) { +#ifdef MS_WIN32 + if (self->index) + return PyTuple_GetSlice(inargs, 1, PyTuple_GET_SIZE(inargs)); +#endif + return Py_NewRef(inargs); + } + + len = PyTuple_GET_SIZE(argtypes); + callargs = PyTuple_New(len); /* the argument tuple we build */ + if (callargs == NULL) + return NULL; + +#ifdef MS_WIN32 + /* For a COM method, skip the first arg */ + if (self->index) { + inargs_index = 1; + } +#endif + for (i = 0; i < len; ++i) { + PyObject *item = PyTuple_GET_ITEM(paramflags, i); + PyObject *ob; + unsigned int flag; + PyObject *name = NULL; + PyObject *defval = NULL; + + /* This way seems to be ~2 us faster than the PyArg_ParseTuple + calls below. */ + /* We HAVE already checked that the tuple can be parsed with "i|ZO", so... */ + Py_ssize_t tsize = PyTuple_GET_SIZE(item); + flag = PyLong_AsUnsignedLongMask(PyTuple_GET_ITEM(item, 0)); + name = tsize > 1 ? PyTuple_GET_ITEM(item, 1) : NULL; + defval = tsize > 2 ? PyTuple_GET_ITEM(item, 2) : NULL; + + switch (flag & (PARAMFLAG_FIN | PARAMFLAG_FOUT | PARAMFLAG_FLCID)) { + case PARAMFLAG_FIN | PARAMFLAG_FLCID: + /* ['in', 'lcid'] parameter. Always taken from defval, + if given, else the integer 0. */ + if (defval == NULL) { + defval = _PyLong_GetZero(); + } + Py_INCREF(defval); + PyTuple_SET_ITEM(callargs, i, defval); + break; + case (PARAMFLAG_FIN | PARAMFLAG_FOUT): + *pinoutmask |= (1 << i); /* mark as inout arg */ + (*pnumretvals)++; + /* fall through */ + case 0: + case PARAMFLAG_FIN: + /* 'in' parameter. Copy it from inargs. */ + ob =_get_arg(&inargs_index, name, defval, inargs, kwds); + if (ob == NULL) + goto error; + PyTuple_SET_ITEM(callargs, i, ob); + break; + case PARAMFLAG_FOUT: + /* XXX Refactor this code into a separate function. */ + /* 'out' parameter. + argtypes[i] must be a POINTER to a c type. + + Cannot by supplied in inargs, but a defval will be used + if available. XXX Should we support getting it from kwds? + */ + if (defval) { + /* XXX Using mutable objects as defval will + make the function non-threadsafe, unless we + copy the object in each invocation */ + Py_INCREF(defval); + PyTuple_SET_ITEM(callargs, i, defval); + *poutmask |= (1 << i); /* mark as out arg */ + (*pnumretvals)++; + break; + } + ob = PyTuple_GET_ITEM(argtypes, i); + dict = PyType_stgdict(ob); + if (dict == NULL) { + /* Cannot happen: _validate_paramflags() + would not accept such an object */ + PyErr_Format(PyExc_RuntimeError, + "NULL stgdict unexpected"); + goto error; + } + if (PyUnicode_Check(dict->proto)) { + PyErr_Format( + PyExc_TypeError, + "%s 'out' parameter must be passed as default value", + ((PyTypeObject *)ob)->tp_name); + goto error; + } + if (PyCArrayTypeObject_Check(ob)) + ob = _PyObject_CallNoArgs(ob); + else + /* Create an instance of the pointed-to type */ + ob = _PyObject_CallNoArgs(dict->proto); + /* + XXX Is the following correct any longer? + We must not pass a byref() to the array then but + the array instance itself. Then, we cannot retrieve + the result from the PyCArgObject. + */ + if (ob == NULL) + goto error; + /* The .from_param call that will occur later will pass this + as a byref parameter. */ + PyTuple_SET_ITEM(callargs, i, ob); + *poutmask |= (1 << i); /* mark as out arg */ + (*pnumretvals)++; + break; + default: + PyErr_Format(PyExc_ValueError, + "paramflag %u not yet implemented", flag); + goto error; + break; + } + } + + /* We have counted the arguments we have consumed in 'inargs_index'. This + must be the same as len(inargs) + len(kwds), otherwise we have + either too much or not enough arguments. */ + + actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_GET_SIZE(kwds) : 0); + if (actual_args != inargs_index) { + /* When we have default values or named parameters, this error + message is misleading. See unittests/test_paramflags.py + */ + PyErr_Format(PyExc_TypeError, + "call takes exactly %d arguments (%zd given)", + inargs_index, actual_args); + goto error; + } + + /* outmask is a bitmask containing indexes into callargs. Items at + these indexes contain values to return. + */ + return callargs; + error: + Py_DECREF(callargs); + return NULL; +} + +/* See also: + http://msdn.microsoft.com/library/en-us/com/html/769127a1-1a14-4ed4-9d38-7cf3e571b661.asp +*/ +/* + Build return value of a function. + + Consumes the refcount on result and callargs. +*/ +static PyObject * +_build_result(PyObject *result, PyObject *callargs, + int outmask, int inoutmask, unsigned int numretvals) +{ + unsigned int i, index; + int bit; + PyObject *tup = NULL; + + if (callargs == NULL) + return result; + if (result == NULL || numretvals == 0) { + Py_DECREF(callargs); + return result; + } + Py_DECREF(result); + + /* tup will not be allocated if numretvals == 1 */ + /* allocate tuple to hold the result */ + if (numretvals > 1) { + tup = PyTuple_New(numretvals); + if (tup == NULL) { + Py_DECREF(callargs); + return NULL; + } + } + + index = 0; + for (bit = 1, i = 0; i < 32; ++i, bit <<= 1) { + PyObject *v; + if (bit & inoutmask) { + v = PyTuple_GET_ITEM(callargs, i); + Py_INCREF(v); + if (numretvals == 1) { + Py_DECREF(callargs); + return v; + } + PyTuple_SET_ITEM(tup, index, v); + index++; + } else if (bit & outmask) { + + v = PyTuple_GET_ITEM(callargs, i); + v = PyObject_CallMethodNoArgs(v, _Py_ID(__ctypes_from_outparam__)); + if (v == NULL || numretvals == 1) { + Py_DECREF(callargs); + return v; + } + PyTuple_SET_ITEM(tup, index, v); + index++; + } + if (index == numretvals) + break; + } + + Py_DECREF(callargs); + return tup; +} + +static PyObject * +PyCFuncPtr_call(PyCFuncPtrObject *self, PyObject *inargs, PyObject *kwds) +{ + PyObject *restype; + PyObject *converters; + PyObject *checker; + PyObject *argtypes; + StgDictObject *dict = PyObject_stgdict((PyObject *)self); + PyObject *result; + PyObject *callargs; + PyObject *errcheck; +#ifdef MS_WIN32 + IUnknown *piunk = NULL; +#endif + void *pProc = NULL; + + int inoutmask; + int outmask; + unsigned int numretvals; + + assert(dict); /* Cannot be NULL for PyCFuncPtrObject instances */ + restype = self->restype ? self->restype : dict->restype; + converters = self->converters ? self->converters : dict->converters; + checker = self->checker ? self->checker : dict->checker; + argtypes = self->argtypes ? self->argtypes : dict->argtypes; +/* later, we probably want to have an errcheck field in stgdict */ + errcheck = self->errcheck /* ? self->errcheck : dict->errcheck */; + + + pProc = *(void **)self->b_ptr; +#ifdef MS_WIN32 + if (self->index) { + /* It's a COM method */ + CDataObject *this; + this = (CDataObject *)PyTuple_GetItem(inargs, 0); /* borrowed ref! */ + if (!this) { + PyErr_SetString(PyExc_ValueError, + "native com method call without 'this' parameter"); + return NULL; + } + if (!CDataObject_Check(this)) { + PyErr_SetString(PyExc_TypeError, + "Expected a COM this pointer as first argument"); + return NULL; + } + /* there should be more checks? No, in Python */ + /* First arg is a pointer to an interface instance */ + if (!this->b_ptr || *(void **)this->b_ptr == NULL) { + PyErr_SetString(PyExc_ValueError, + "NULL COM pointer access"); + return NULL; + } + piunk = *(IUnknown **)this->b_ptr; + if (NULL == piunk->lpVtbl) { + PyErr_SetString(PyExc_ValueError, + "COM method call without VTable"); + return NULL; + } + pProc = ((void **)piunk->lpVtbl)[self->index - 0x1000]; + } +#endif + callargs = _build_callargs(self, argtypes, + inargs, kwds, + &outmask, &inoutmask, &numretvals); + if (callargs == NULL) + return NULL; + + if (converters) { + int required = Py_SAFE_DOWNCAST(PyTuple_GET_SIZE(converters), + Py_ssize_t, int); + int actual = Py_SAFE_DOWNCAST(PyTuple_GET_SIZE(callargs), + Py_ssize_t, int); + + if ((dict->flags & FUNCFLAG_CDECL) == FUNCFLAG_CDECL) { + /* For cdecl functions, we allow more actual arguments + than the length of the argtypes tuple. + */ + if (required > actual) { + Py_DECREF(callargs); + PyErr_Format(PyExc_TypeError, + "this function takes at least %d argument%s (%d given)", + required, + required == 1 ? "" : "s", + actual); + return NULL; + } + } else if (required != actual) { + Py_DECREF(callargs); + PyErr_Format(PyExc_TypeError, + "this function takes %d argument%s (%d given)", + required, + required == 1 ? "" : "s", + actual); + return NULL; + } + } + + result = _ctypes_callproc(pProc, + callargs, +#ifdef MS_WIN32 + piunk, + self->iid, +#endif + dict->flags, + converters, + restype, + checker); +/* The 'errcheck' protocol */ + if (result != NULL && errcheck) { + PyObject *v = PyObject_CallFunctionObjArgs(errcheck, + result, + self, + callargs, + NULL); + /* If the errcheck function failed, return NULL. + If the errcheck function returned callargs unchanged, + continue normal processing. + If the errcheck function returned something else, + use that as result. + */ + if (v == NULL || v != callargs) { + Py_DECREF(result); + Py_DECREF(callargs); + return v; + } + Py_DECREF(v); + } + + return _build_result(result, callargs, + outmask, inoutmask, numretvals); +} + +static int +PyCFuncPtr_traverse(PyCFuncPtrObject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->callable); + Py_VISIT(self->restype); + Py_VISIT(self->checker); + Py_VISIT(self->errcheck); + Py_VISIT(self->argtypes); + Py_VISIT(self->converters); + Py_VISIT(self->paramflags); + Py_VISIT(self->thunk); + return PyCData_traverse((CDataObject *)self, visit, arg); +} + +static int +PyCFuncPtr_clear(PyCFuncPtrObject *self) +{ + Py_CLEAR(self->callable); + Py_CLEAR(self->restype); + Py_CLEAR(self->checker); + Py_CLEAR(self->errcheck); + Py_CLEAR(self->argtypes); + Py_CLEAR(self->converters); + Py_CLEAR(self->paramflags); + Py_CLEAR(self->thunk); + return PyCData_clear((CDataObject *)self); +} + +static void +PyCFuncPtr_dealloc(PyCFuncPtrObject *self) +{ + PyCFuncPtr_clear(self); + Py_TYPE(self)->tp_free((PyObject *)self); +} + +static PyObject * +PyCFuncPtr_repr(PyCFuncPtrObject *self) +{ +#ifdef MS_WIN32 + if (self->index) + return PyUnicode_FromFormat("", + self->index - 0x1000, + Py_TYPE(self)->tp_name, + self); +#endif + return PyUnicode_FromFormat("<%s object at %p>", + Py_TYPE(self)->tp_name, + self); +} + +static int +PyCFuncPtr_bool(PyCFuncPtrObject *self) +{ + return ((*(void **)self->b_ptr != NULL) +#ifdef MS_WIN32 + || (self->index != 0) +#endif + ); +} + +static PyNumberMethods PyCFuncPtr_as_number = { + 0, /* nb_add */ + 0, /* nb_subtract */ + 0, /* nb_multiply */ + 0, /* nb_remainder */ + 0, /* nb_divmod */ + 0, /* nb_power */ + 0, /* nb_negative */ + 0, /* nb_positive */ + 0, /* nb_absolute */ + (inquiry)PyCFuncPtr_bool, /* nb_bool */ +}; + +PyTypeObject PyCFuncPtr_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.CFuncPtr", + sizeof(PyCFuncPtrObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)PyCFuncPtr_dealloc, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + (reprfunc)PyCFuncPtr_repr, /* tp_repr */ + &PyCFuncPtr_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + (ternaryfunc)PyCFuncPtr_call, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("Function Pointer"), /* tp_doc */ + (traverseproc)PyCFuncPtr_traverse, /* tp_traverse */ + (inquiry)PyCFuncPtr_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + PyCFuncPtr_getsets, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + PyCFuncPtr_new, /* tp_new */ + 0, /* tp_free */ +}; + +/*****************************************************************/ +/* + Struct_Type +*/ +/* + This function is called to initialize a Structure or Union with positional + arguments. It calls itself recursively for all Structure or Union base + classes, then retrieves the _fields_ member to associate the argument + position with the correct field name. + + Returns -1 on error, or the index of next argument on success. + */ +static Py_ssize_t +_init_pos_args(PyObject *self, PyTypeObject *type, + PyObject *args, PyObject *kwds, + Py_ssize_t index) +{ + StgDictObject *dict; + PyObject *fields; + Py_ssize_t i; + + if (PyType_stgdict((PyObject *)type->tp_base)) { + index = _init_pos_args(self, type->tp_base, + args, kwds, + index); + if (index == -1) + return -1; + } + + dict = PyType_stgdict((PyObject *)type); + fields = PyDict_GetItemWithError((PyObject *)dict, _Py_ID(_fields_)); + if (fields == NULL) { + if (PyErr_Occurred()) { + return -1; + } + return index; + } + + for (i = index; + i < dict->length && i < PyTuple_GET_SIZE(args); + ++i) { + PyObject *pair = PySequence_GetItem(fields, i - index); + PyObject *name, *val; + int res; + if (!pair) + return -1; + name = PySequence_GetItem(pair, 0); + if (!name) { + Py_DECREF(pair); + return -1; + } + val = PyTuple_GET_ITEM(args, i); + if (kwds) { + res = PyDict_Contains(kwds, name); + if (res != 0) { + if (res > 0) { + PyErr_Format(PyExc_TypeError, + "duplicate values for field %R", + name); + } + Py_DECREF(pair); + Py_DECREF(name); + return -1; + } + } + + res = PyObject_SetAttr(self, name, val); + Py_DECREF(pair); + Py_DECREF(name); + if (res == -1) + return -1; + } + return dict->length; +} + +static int +Struct_init(PyObject *self, PyObject *args, PyObject *kwds) +{ +/* Optimization possible: Store the attribute names _fields_[x][0] + * in C accessible fields somewhere ? + */ + if (!PyTuple_Check(args)) { + PyErr_SetString(PyExc_TypeError, + "args not a tuple?"); + return -1; + } + if (PyTuple_GET_SIZE(args)) { + Py_ssize_t res = _init_pos_args(self, Py_TYPE(self), + args, kwds, 0); + if (res == -1) + return -1; + if (res < PyTuple_GET_SIZE(args)) { + PyErr_SetString(PyExc_TypeError, + "too many initializers"); + return -1; + } + } + + if (kwds) { + PyObject *key, *value; + Py_ssize_t pos = 0; + while(PyDict_Next(kwds, &pos, &key, &value)) { + if (-1 == PyObject_SetAttr(self, key, value)) + return -1; + } + } + return 0; +} + +static PyTypeObject Struct_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.Structure", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("Structure base class"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + Struct_init, /* tp_init */ + 0, /* tp_alloc */ + GenericPyCData_new, /* tp_new */ + 0, /* tp_free */ +}; + +static PyTypeObject Union_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.Union", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("Union base class"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + Struct_init, /* tp_init */ + 0, /* tp_alloc */ + GenericPyCData_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/******************************************************************/ +/* + PyCArray_Type +*/ +static int +Array_init(CDataObject *self, PyObject *args, PyObject *kw) +{ + Py_ssize_t i; + Py_ssize_t n; + + if (!PyTuple_Check(args)) { + PyErr_SetString(PyExc_TypeError, + "args not a tuple?"); + return -1; + } + n = PyTuple_GET_SIZE(args); + for (i = 0; i < n; ++i) { + PyObject *v; + v = PyTuple_GET_ITEM(args, i); + if (-1 == PySequence_SetItem((PyObject *)self, i, v)) + return -1; + } + return 0; +} + +static PyObject * +Array_item(PyObject *myself, Py_ssize_t index) +{ + CDataObject *self = (CDataObject *)myself; + Py_ssize_t offset, size; + StgDictObject *stgdict; + + + if (index < 0 || index >= self->b_length) { + PyErr_SetString(PyExc_IndexError, + "invalid index"); + return NULL; + } + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for array instances */ + /* Would it be clearer if we got the item size from + stgdict->proto's stgdict? + */ + size = stgdict->size / stgdict->length; + offset = index * size; + + return PyCData_get(stgdict->proto, stgdict->getfunc, (PyObject *)self, + index, size, self->b_ptr + offset); +} + +static PyObject * +Array_subscript(PyObject *myself, PyObject *item) +{ + CDataObject *self = (CDataObject *)myself; + + if (PyIndex_Check(item)) { + Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); + + if (i == -1 && PyErr_Occurred()) + return NULL; + if (i < 0) + i += self->b_length; + return Array_item(myself, i); + } + else if (PySlice_Check(item)) { + StgDictObject *stgdict, *itemdict; + PyObject *proto; + PyObject *np; + Py_ssize_t start, stop, step, slicelen, i; + size_t cur; + + if (PySlice_Unpack(item, &start, &stop, &step) < 0) { + return NULL; + } + slicelen = PySlice_AdjustIndices(self->b_length, &start, &stop, step); + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for array object instances */ + proto = stgdict->proto; + itemdict = PyType_stgdict(proto); + assert(itemdict); /* proto is the item type of the array, a + ctypes type, so this cannot be NULL */ + + if (itemdict->getfunc == _ctypes_get_fielddesc("c")->getfunc) { + char *ptr = (char *)self->b_ptr; + char *dest; + + if (slicelen <= 0) + return PyBytes_FromStringAndSize("", 0); + if (step == 1) { + return PyBytes_FromStringAndSize(ptr + start, + slicelen); + } + dest = (char *)PyMem_Malloc(slicelen); + + if (dest == NULL) + return PyErr_NoMemory(); + + for (cur = start, i = 0; i < slicelen; + cur += step, i++) { + dest[i] = ptr[cur]; + } + + np = PyBytes_FromStringAndSize(dest, slicelen); + PyMem_Free(dest); + return np; + } + if (itemdict->getfunc == _ctypes_get_fielddesc("u")->getfunc) { + wchar_t *ptr = (wchar_t *)self->b_ptr; + wchar_t *dest; + + if (slicelen <= 0) + return PyUnicode_New(0, 0); + if (step == 1) { + return PyUnicode_FromWideChar(ptr + start, + slicelen); + } + + dest = PyMem_New(wchar_t, slicelen); + if (dest == NULL) { + PyErr_NoMemory(); + return NULL; + } + + for (cur = start, i = 0; i < slicelen; + cur += step, i++) { + dest[i] = ptr[cur]; + } + + np = PyUnicode_FromWideChar(dest, slicelen); + PyMem_Free(dest); + return np; + } + + np = PyList_New(slicelen); + if (np == NULL) + return NULL; + + for (cur = start, i = 0; i < slicelen; + cur += step, i++) { + PyObject *v = Array_item(myself, cur); + if (v == NULL) { + Py_DECREF(np); + return NULL; + } + PyList_SET_ITEM(np, i, v); + } + return np; + } + else { + PyErr_SetString(PyExc_TypeError, + "indices must be integers"); + return NULL; + } + +} + +static int +Array_ass_item(PyObject *myself, Py_ssize_t index, PyObject *value) +{ + CDataObject *self = (CDataObject *)myself; + Py_ssize_t size, offset; + StgDictObject *stgdict; + char *ptr; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "Array does not support item deletion"); + return -1; + } + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for array object instances */ + if (index < 0 || index >= stgdict->length) { + PyErr_SetString(PyExc_IndexError, + "invalid index"); + return -1; + } + size = stgdict->size / stgdict->length; + offset = index * size; + ptr = self->b_ptr + offset; + + return PyCData_set((PyObject *)self, stgdict->proto, stgdict->setfunc, value, + index, size, ptr); +} + +static int +Array_ass_subscript(PyObject *myself, PyObject *item, PyObject *value) +{ + CDataObject *self = (CDataObject *)myself; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "Array does not support item deletion"); + return -1; + } + + if (PyIndex_Check(item)) { + Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); + + if (i == -1 && PyErr_Occurred()) + return -1; + if (i < 0) + i += self->b_length; + return Array_ass_item(myself, i, value); + } + else if (PySlice_Check(item)) { + Py_ssize_t start, stop, step, slicelen, otherlen, i; + size_t cur; + + if (PySlice_Unpack(item, &start, &stop, &step) < 0) { + return -1; + } + slicelen = PySlice_AdjustIndices(self->b_length, &start, &stop, step); + if ((step < 0 && start < stop) || + (step > 0 && start > stop)) + stop = start; + + otherlen = PySequence_Length(value); + if (otherlen != slicelen) { + PyErr_SetString(PyExc_ValueError, + "Can only assign sequence of same size"); + return -1; + } + for (cur = start, i = 0; i < otherlen; cur += step, i++) { + PyObject *item = PySequence_GetItem(value, i); + int result; + if (item == NULL) + return -1; + result = Array_ass_item(myself, cur, item); + Py_DECREF(item); + if (result == -1) + return -1; + } + return 0; + } + else { + PyErr_SetString(PyExc_TypeError, + "indices must be integer"); + return -1; + } +} + +static Py_ssize_t +Array_length(PyObject *myself) +{ + CDataObject *self = (CDataObject *)myself; + return self->b_length; +} + +static PyMethodDef Array_methods[] = { + {"__class_getitem__", Py_GenericAlias, + METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, + { NULL, NULL } +}; + +static PySequenceMethods Array_as_sequence = { + Array_length, /* sq_length; */ + 0, /* sq_concat; */ + 0, /* sq_repeat; */ + Array_item, /* sq_item; */ + 0, /* sq_slice; */ + Array_ass_item, /* sq_ass_item; */ + 0, /* sq_ass_slice; */ + 0, /* sq_contains; */ + + 0, /* sq_inplace_concat; */ + 0, /* sq_inplace_repeat; */ +}; + +static PyMappingMethods Array_as_mapping = { + Array_length, + Array_subscript, + Array_ass_subscript, +}; + +PyTypeObject PyCArray_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes.Array", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + &Array_as_sequence, /* tp_as_sequence */ + &Array_as_mapping, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("XXX to be provided"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + Array_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Array_init, /* tp_init */ + 0, /* tp_alloc */ + GenericPyCData_new, /* tp_new */ + 0, /* tp_free */ +}; + +PyObject * +PyCArrayType_from_ctype(PyObject *itemtype, Py_ssize_t length) +{ + static PyObject *cache; + PyObject *key; + PyObject *result; + char name[256]; + PyObject *len; + + if (cache == NULL) { + cache = PyDict_New(); + if (cache == NULL) + return NULL; + } + len = PyLong_FromSsize_t(length); + if (len == NULL) + return NULL; + key = PyTuple_Pack(2, itemtype, len); + Py_DECREF(len); + if (!key) + return NULL; + result = PyDict_GetItemProxy(cache, key); + if (result) { + Py_INCREF(result); + Py_DECREF(key); + return result; + } + else if (PyErr_Occurred()) { + Py_DECREF(key); + return NULL; + } + + if (!PyType_Check(itemtype)) { + PyErr_SetString(PyExc_TypeError, + "Expected a type object"); + Py_DECREF(key); + return NULL; + } +#ifdef MS_WIN64 + sprintf(name, "%.200s_Array_%Id", + ((PyTypeObject *)itemtype)->tp_name, length); +#else + sprintf(name, "%.200s_Array_%ld", + ((PyTypeObject *)itemtype)->tp_name, (long)length); +#endif + + result = PyObject_CallFunction((PyObject *)&PyCArrayType_Type, + "s(O){s:n,s:O}", + name, + &PyCArray_Type, + "_length_", + length, + "_type_", + itemtype + ); + if (result == NULL) { + Py_DECREF(key); + return NULL; + } + if (-1 == PyDict_SetItemProxy(cache, key, result)) { + Py_DECREF(key); + Py_DECREF(result); + return NULL; + } + Py_DECREF(key); + return result; +} + + +/******************************************************************/ +/* + Simple_Type +*/ + +static int +Simple_set_value(CDataObject *self, PyObject *value, void *Py_UNUSED(ignored)) +{ + PyObject *result; + StgDictObject *dict = PyObject_stgdict((PyObject *)self); + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "can't delete attribute"); + return -1; + } + assert(dict); /* Cannot be NULL for CDataObject instances */ + assert(dict->setfunc); + result = dict->setfunc(self->b_ptr, value, dict->size); + if (!result) + return -1; + + /* consumes the refcount the setfunc returns */ + return KeepRef(self, 0, result); +} + +static int +Simple_init(CDataObject *self, PyObject *args, PyObject *kw) +{ + PyObject *value = NULL; + if (!PyArg_UnpackTuple(args, "__init__", 0, 1, &value)) + return -1; + if (value) + return Simple_set_value(self, value, NULL); + return 0; +} + +static PyObject * +Simple_get_value(CDataObject *self, void *Py_UNUSED(ignored)) +{ + StgDictObject *dict; + dict = PyObject_stgdict((PyObject *)self); + assert(dict); /* Cannot be NULL for CDataObject instances */ + assert(dict->getfunc); + return dict->getfunc(self->b_ptr, self->b_size); +} + +static PyGetSetDef Simple_getsets[] = { + { "value", (getter)Simple_get_value, (setter)Simple_set_value, + "current value", NULL }, + { NULL, NULL } +}; + +static PyObject * +Simple_from_outparm(PyObject *self, PyObject *args) +{ + if (_ctypes_simple_instance((PyObject *)Py_TYPE(self))) { + return Py_NewRef(self); + } + /* call stgdict->getfunc */ + return Simple_get_value((CDataObject *)self, NULL); +} + +static PyMethodDef Simple_methods[] = { + { "__ctypes_from_outparam__", Simple_from_outparm, METH_NOARGS, }, + { NULL, NULL }, +}; + +static int Simple_bool(CDataObject *self) +{ + return memcmp(self->b_ptr, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", self->b_size); +} + +static PyNumberMethods Simple_as_number = { + 0, /* nb_add */ + 0, /* nb_subtract */ + 0, /* nb_multiply */ + 0, /* nb_remainder */ + 0, /* nb_divmod */ + 0, /* nb_power */ + 0, /* nb_negative */ + 0, /* nb_positive */ + 0, /* nb_absolute */ + (inquiry)Simple_bool, /* nb_bool */ +}; + +/* "%s(%s)" % (self.__class__.__name__, self.value) */ +static PyObject * +Simple_repr(CDataObject *self) +{ + PyObject *val, *result; + + if (Py_TYPE(self)->tp_base != &Simple_Type) { + return PyUnicode_FromFormat("<%s object at %p>", + Py_TYPE(self)->tp_name, self); + } + + val = Simple_get_value(self, NULL); + if (val == NULL) + return NULL; + + result = PyUnicode_FromFormat("%s(%R)", + Py_TYPE(self)->tp_name, val); + Py_DECREF(val); + return result; +} + +static PyTypeObject Simple_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes._SimpleCData", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + (reprfunc)&Simple_repr, /* tp_repr */ + &Simple_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("XXX to be provided"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + Simple_methods, /* tp_methods */ + 0, /* tp_members */ + Simple_getsets, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Simple_init, /* tp_init */ + 0, /* tp_alloc */ + GenericPyCData_new, /* tp_new */ + 0, /* tp_free */ +}; + +/******************************************************************/ +/* + PyCPointer_Type +*/ +static PyObject * +Pointer_item(PyObject *myself, Py_ssize_t index) +{ + CDataObject *self = (CDataObject *)myself; + Py_ssize_t size; + Py_ssize_t offset; + StgDictObject *stgdict, *itemdict; + PyObject *proto; + + if (*(void **)self->b_ptr == NULL) { + PyErr_SetString(PyExc_ValueError, + "NULL pointer access"); + return NULL; + } + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for pointer object instances */ + + proto = stgdict->proto; + assert(proto); + itemdict = PyType_stgdict(proto); + assert(itemdict); /* proto is the item type of the pointer, a ctypes + type, so this cannot be NULL */ + + size = itemdict->size; + offset = index * itemdict->size; + + return PyCData_get(proto, stgdict->getfunc, (PyObject *)self, + index, size, (*(char **)self->b_ptr) + offset); +} + +static int +Pointer_ass_item(PyObject *myself, Py_ssize_t index, PyObject *value) +{ + CDataObject *self = (CDataObject *)myself; + Py_ssize_t size; + Py_ssize_t offset; + StgDictObject *stgdict, *itemdict; + PyObject *proto; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "Pointer does not support item deletion"); + return -1; + } + + if (*(void **)self->b_ptr == NULL) { + PyErr_SetString(PyExc_ValueError, + "NULL pointer access"); + return -1; + } + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for pointer instances */ + + proto = stgdict->proto; + assert(proto); + + itemdict = PyType_stgdict(proto); + assert(itemdict); /* Cannot be NULL because the itemtype of a pointer + is always a ctypes type */ + + size = itemdict->size; + offset = index * itemdict->size; + + return PyCData_set((PyObject *)self, proto, stgdict->setfunc, value, + index, size, (*(char **)self->b_ptr) + offset); +} + +static PyObject * +Pointer_get_contents(CDataObject *self, void *closure) +{ + StgDictObject *stgdict; + + if (*(void **)self->b_ptr == NULL) { + PyErr_SetString(PyExc_ValueError, + "NULL pointer access"); + return NULL; + } + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for pointer instances */ + return PyCData_FromBaseObj(stgdict->proto, + (PyObject *)self, 0, + *(void **)self->b_ptr); +} + +static int +Pointer_set_contents(CDataObject *self, PyObject *value, void *closure) +{ + StgDictObject *stgdict; + CDataObject *dst; + PyObject *keep; + + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "Pointer does not support item deletion"); + return -1; + } + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for pointer instances */ + assert(stgdict->proto); + if (!CDataObject_Check(value)) { + int res = PyObject_IsInstance(value, stgdict->proto); + if (res == -1) + return -1; + if (!res) { + PyErr_Format(PyExc_TypeError, + "expected %s instead of %s", + ((PyTypeObject *)(stgdict->proto))->tp_name, + Py_TYPE(value)->tp_name); + return -1; + } + } + + dst = (CDataObject *)value; + *(void **)self->b_ptr = dst->b_ptr; + + /* + A Pointer instance must keep the value it points to alive. So, a + pointer instance has b_length set to 2 instead of 1, and we set + 'value' itself as the second item of the b_objects list, additionally. + */ + Py_INCREF(value); + if (-1 == KeepRef(self, 1, value)) + return -1; + + keep = GetKeepedObjects(dst); + if (keep == NULL) + return -1; + + Py_INCREF(keep); + return KeepRef(self, 0, keep); +} + +static PyGetSetDef Pointer_getsets[] = { + { "contents", (getter)Pointer_get_contents, + (setter)Pointer_set_contents, + "the object this pointer points to (read-write)", NULL }, + { NULL, NULL } +}; + +static int +Pointer_init(CDataObject *self, PyObject *args, PyObject *kw) +{ + PyObject *value = NULL; + + if (!PyArg_UnpackTuple(args, "POINTER", 0, 1, &value)) + return -1; + if (value == NULL) + return 0; + return Pointer_set_contents(self, value, NULL); +} + +static PyObject * +Pointer_new(PyTypeObject *type, PyObject *args, PyObject *kw) +{ + StgDictObject *dict = PyType_stgdict((PyObject *)type); + if (!dict || !dict->proto) { + PyErr_SetString(PyExc_TypeError, + "Cannot create instance: has no _type_"); + return NULL; + } + return GenericPyCData_new(type, args, kw); +} + +static PyObject * +Pointer_subscript(PyObject *myself, PyObject *item) +{ + CDataObject *self = (CDataObject *)myself; + if (PyIndex_Check(item)) { + Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); + if (i == -1 && PyErr_Occurred()) + return NULL; + return Pointer_item(myself, i); + } + else if (PySlice_Check(item)) { + PySliceObject *slice = (PySliceObject *)item; + Py_ssize_t start, stop, step; + PyObject *np; + StgDictObject *stgdict, *itemdict; + PyObject *proto; + Py_ssize_t i, len; + size_t cur; + + /* Since pointers have no length, and we want to apply + different semantics to negative indices than normal + slicing, we have to dissect the slice object ourselves.*/ + if (GraalPySlice_Step((PyObject *)slice) == Py_None) { + step = 1; + } + else { + step = PyNumber_AsSsize_t(GraalPySlice_Step((PyObject *)slice), + PyExc_ValueError); + if (step == -1 && PyErr_Occurred()) + return NULL; + if (step == 0) { + PyErr_SetString(PyExc_ValueError, + "slice step cannot be zero"); + return NULL; + } + } + if (GraalPySlice_Start((PyObject *)slice) == Py_None) { + if (step < 0) { + PyErr_SetString(PyExc_ValueError, + "slice start is required " + "for step < 0"); + return NULL; + } + start = 0; + } + else { + start = PyNumber_AsSsize_t(GraalPySlice_Start((PyObject *)slice), + PyExc_ValueError); + if (start == -1 && PyErr_Occurred()) + return NULL; + } + if (GraalPySlice_Stop((PyObject *)slice) == Py_None) { + PyErr_SetString(PyExc_ValueError, + "slice stop is required"); + return NULL; + } + stop = PyNumber_AsSsize_t(GraalPySlice_Stop((PyObject *)slice), + PyExc_ValueError); + if (stop == -1 && PyErr_Occurred()) + return NULL; + if ((step > 0 && start > stop) || + (step < 0 && start < stop)) + len = 0; + else if (step > 0) + len = (stop - start - 1) / step + 1; + else + len = (stop - start + 1) / step + 1; + + stgdict = PyObject_stgdict((PyObject *)self); + assert(stgdict); /* Cannot be NULL for pointer instances */ + proto = stgdict->proto; + assert(proto); + itemdict = PyType_stgdict(proto); + assert(itemdict); + if (itemdict->getfunc == _ctypes_get_fielddesc("c")->getfunc) { + char *ptr = *(char **)self->b_ptr; + char *dest; + + if (len <= 0) + return PyBytes_FromStringAndSize("", 0); + if (step == 1) { + return PyBytes_FromStringAndSize(ptr + start, + len); + } + dest = (char *)PyMem_Malloc(len); + if (dest == NULL) + return PyErr_NoMemory(); + for (cur = start, i = 0; i < len; cur += step, i++) { + dest[i] = ptr[cur]; + } + np = PyBytes_FromStringAndSize(dest, len); + PyMem_Free(dest); + return np; + } + if (itemdict->getfunc == _ctypes_get_fielddesc("u")->getfunc) { + wchar_t *ptr = *(wchar_t **)self->b_ptr; + wchar_t *dest; + + if (len <= 0) + return PyUnicode_New(0, 0); + if (step == 1) { + return PyUnicode_FromWideChar(ptr + start, + len); + } + dest = PyMem_New(wchar_t, len); + if (dest == NULL) + return PyErr_NoMemory(); + for (cur = start, i = 0; i < len; cur += step, i++) { + dest[i] = ptr[cur]; + } + np = PyUnicode_FromWideChar(dest, len); + PyMem_Free(dest); + return np; + } + + np = PyList_New(len); + if (np == NULL) + return NULL; + + for (cur = start, i = 0; i < len; cur += step, i++) { + PyObject *v = Pointer_item(myself, cur); + PyList_SET_ITEM(np, i, v); + } + return np; + } + else { + PyErr_SetString(PyExc_TypeError, + "Pointer indices must be integer"); + return NULL; + } +} + +static PySequenceMethods Pointer_as_sequence = { + 0, /* inquiry sq_length; */ + 0, /* binaryfunc sq_concat; */ + 0, /* intargfunc sq_repeat; */ + Pointer_item, /* intargfunc sq_item; */ + 0, /* intintargfunc sq_slice; */ + Pointer_ass_item, /* intobjargproc sq_ass_item; */ + 0, /* intintobjargproc sq_ass_slice; */ + 0, /* objobjproc sq_contains; */ + /* Added in release 2.0 */ + 0, /* binaryfunc sq_inplace_concat; */ + 0, /* intargfunc sq_inplace_repeat; */ +}; + +static PyMappingMethods Pointer_as_mapping = { + 0, + Pointer_subscript, +}; + +static int +Pointer_bool(CDataObject *self) +{ + return (*(void **)self->b_ptr != NULL); +} + +static PyNumberMethods Pointer_as_number = { + 0, /* nb_add */ + 0, /* nb_subtract */ + 0, /* nb_multiply */ + 0, /* nb_remainder */ + 0, /* nb_divmod */ + 0, /* nb_power */ + 0, /* nb_negative */ + 0, /* nb_positive */ + 0, /* nb_absolute */ + (inquiry)Pointer_bool, /* nb_bool */ +}; + +PyTypeObject PyCPointer_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "_ctypes._Pointer", + sizeof(CDataObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + &Pointer_as_number, /* tp_as_number */ + &Pointer_as_sequence, /* tp_as_sequence */ + &Pointer_as_mapping, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + &PyCData_as_buffer, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + PyDoc_STR("XXX to be provided"), /* tp_doc */ + (traverseproc)PyCData_traverse, /* tp_traverse */ + (inquiry)PyCData_clear, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + Pointer_getsets, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Pointer_init, /* tp_init */ + 0, /* tp_alloc */ + Pointer_new, /* tp_new */ + 0, /* tp_free */ +}; + + +/******************************************************************/ +/* + * Module initialization. + */ + +PyDoc_STRVAR(_ctypes__doc__, +"Create and manipulate C compatible data types in Python."); + +#ifdef MS_WIN32 + +PyDoc_STRVAR(comerror_doc, "Raised when a COM method call failed."); + +int +comerror_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + PyObject *hresult, *text, *details; + PyObject *a; + int status; + + if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds)) + return -1; + + if (!PyArg_ParseTuple(args, "OOO:COMError", &hresult, &text, &details)) + return -1; + + a = PySequence_GetSlice(args, 1, PyTuple_GET_SIZE(args)); + if (!a) + return -1; + status = PyObject_SetAttrString(self, "args", a); + Py_DECREF(a); + if (status < 0) + return -1; + + if (PyObject_SetAttrString(self, "hresult", hresult) < 0) + return -1; + + if (PyObject_SetAttrString(self, "text", text) < 0) + return -1; + + if (PyObject_SetAttrString(self, "details", details) < 0) + return -1; + + Py_INCREF(args); + Py_SETREF(((PyBaseExceptionObject *)self)->args, args); + + return 0; +} + +static int +comerror_clear(PyObject *self) +{ + return ((PyTypeObject *)PyExc_BaseException)->tp_clear(self); +} + +static int +comerror_traverse(PyObject *self, visitproc visit, void *arg) +{ + Py_VISIT(Py_TYPE(self)); + return ((PyTypeObject *)PyExc_BaseException)->tp_traverse(self, visit, arg); +} + +static void +comerror_dealloc(PyObject *self) +{ + PyTypeObject *tp = Py_TYPE(self); + PyObject_GC_UnTrack(self); + (void)comerror_clear(self); + tp->tp_free(self); + Py_DECREF(tp); +} + +static PyType_Slot comerror_slots[] = { + {Py_tp_doc, (void *)PyDoc_STR(comerror_doc)}, + {Py_tp_init, comerror_init}, + {Py_tp_traverse, comerror_traverse}, + {Py_tp_dealloc, comerror_dealloc}, + {Py_tp_clear, comerror_clear}, + {0, NULL}, +}; + +static PyType_Spec comerror_spec = { + .name = "_ctypes.COMError", + .basicsize = sizeof(PyBaseExceptionObject), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | + Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), + .slots = comerror_slots, +}; + +#endif // MS_WIN32 + +static PyObject * +string_at(const char *ptr, int size) +{ + if (PySys_Audit("ctypes.string_at", "ni", (Py_ssize_t)ptr, size) < 0) { + return NULL; + } + if (size == -1) + return PyBytes_FromStringAndSize(ptr, strlen(ptr)); + return PyBytes_FromStringAndSize(ptr, size); +} + +static int +cast_check_pointertype(PyObject *arg) +{ + StgDictObject *dict; + + if (PyCPointerTypeObject_Check(arg)) + return 1; + if (PyCFuncPtrTypeObject_Check(arg)) + return 1; + dict = PyType_stgdict(arg); + if (dict != NULL && dict->proto != NULL) { + if (PyUnicode_Check(dict->proto) + && (strchr("sPzUZXO", PyUnicode_AsUTF8(dict->proto)[0]))) { + /* simple pointer types, c_void_p, c_wchar_p, BSTR, ... */ + return 1; + } + } + PyErr_Format(PyExc_TypeError, + "cast() argument 2 must be a pointer type, not %s", + PyType_Check(arg) + ? ((PyTypeObject *)arg)->tp_name + : Py_TYPE(arg)->tp_name); + return 0; +} + +static PyObject * +cast(void *ptr, PyObject *src, PyObject *ctype) +{ + CDataObject *result; + if (0 == cast_check_pointertype(ctype)) + return NULL; + result = (CDataObject *)_PyObject_CallNoArgs(ctype); + if (result == NULL) + return NULL; + + /* + The casted objects '_objects' member: + + It must certainly contain the source objects one. + It must contain the source object itself. + */ + if (CDataObject_Check(src)) { + CDataObject *obj = (CDataObject *)src; + CDataObject *container; + + /* PyCData_GetContainer will initialize src.b_objects, we need + this so it can be shared */ + container = PyCData_GetContainer(obj); + if (container == NULL) + goto failed; + + /* But we need a dictionary! */ + if (obj->b_objects == Py_None) { + Py_DECREF(Py_None); + obj->b_objects = PyDict_New(); + if (obj->b_objects == NULL) + goto failed; + } + result->b_objects = Py_XNewRef(obj->b_objects); + if (result->b_objects && PyDict_CheckExact(result->b_objects)) { + PyObject *index; + int rc; + index = PyLong_FromVoidPtr((void *)src); + if (index == NULL) + goto failed; + rc = PyDict_SetItem(result->b_objects, index, src); + Py_DECREF(index); + if (rc == -1) + goto failed; + } + } + /* Should we assert that result is a pointer type? */ + memcpy(result->b_ptr, &ptr, sizeof(void *)); + return (PyObject *)result; + + failed: + Py_DECREF(result); + return NULL; +} + + +static PyObject * +wstring_at(const wchar_t *ptr, int size) +{ + Py_ssize_t ssize = size; + if (PySys_Audit("ctypes.wstring_at", "nn", (Py_ssize_t)ptr, ssize) < 0) { + return NULL; + } + if (ssize == -1) + ssize = wcslen(ptr); + return PyUnicode_FromWideChar(ptr, ssize); +} + + +static struct PyModuleDef _ctypesmodule = { + PyModuleDef_HEAD_INIT, + .m_name = "_ctypes", + .m_doc = _ctypes__doc__, + .m_size = -1, + .m_methods = _ctypes_module_methods, +}; + + +static int +_ctypes_add_types(PyObject *mod) +{ +#define TYPE_READY(TYPE) \ + if (PyType_Ready(TYPE) < 0) { \ + return -1; \ + } + +#define TYPE_READY_BASE(TYPE_EXPR, TP_BASE) \ + do { \ + PyTypeObject *type = (TYPE_EXPR); \ + type->tp_base = (TP_BASE); \ + TYPE_READY(type); \ + } while (0) + +#define MOD_ADD_TYPE(TYPE_EXPR, TP_TYPE, TP_BASE) \ + do { \ + PyTypeObject *type = (TYPE_EXPR); \ + Py_SET_TYPE(type, TP_TYPE); \ + type->tp_base = TP_BASE; \ + if (PyModule_AddType(mod, type) < 0) { \ + return -1; \ + } \ + } while (0) + +#define CREATE_TYPE(MOD, TP, SPEC, BASE) do { \ + PyObject *type = PyType_FromMetaclass(NULL, MOD, SPEC, \ + (PyObject *)BASE); \ + if (type == NULL) { \ + return -1; \ + } \ + TP = (PyTypeObject *)type; \ +} while (0) + + ctypes_state *st = GLOBAL_STATE(); + + /* Note: + ob_type is the metatype (the 'type'), defaults to PyType_Type, + tp_base is the base type, defaults to 'object' aka PyBaseObject_Type. + */ + CREATE_TYPE(mod, st->PyCArg_Type, &carg_spec, NULL); + CREATE_TYPE(mod, st->PyCThunk_Type, &cthunk_spec, NULL); + TYPE_READY(&PyCData_Type); + /* StgDict is derived from PyDict_Type */ + TYPE_READY_BASE(&PyCStgDict_Type, &PyDict_Type); + + /************************************************* + * + * Metaclasses + */ + TYPE_READY_BASE(&PyCStructType_Type, &PyType_Type); + TYPE_READY_BASE(&UnionType_Type, &PyType_Type); + TYPE_READY_BASE(&PyCPointerType_Type, &PyType_Type); + TYPE_READY_BASE(&PyCArrayType_Type, &PyType_Type); + TYPE_READY_BASE(&PyCSimpleType_Type, &PyType_Type); + TYPE_READY_BASE(&PyCFuncPtrType_Type, &PyType_Type); + + /************************************************* + * + * Classes using a custom metaclass + */ + + MOD_ADD_TYPE(&Struct_Type, &PyCStructType_Type, &PyCData_Type); + MOD_ADD_TYPE(&Union_Type, &UnionType_Type, &PyCData_Type); + MOD_ADD_TYPE(&PyCPointer_Type, &PyCPointerType_Type, &PyCData_Type); + MOD_ADD_TYPE(&PyCArray_Type, &PyCArrayType_Type, &PyCData_Type); + MOD_ADD_TYPE(&Simple_Type, &PyCSimpleType_Type, &PyCData_Type); + MOD_ADD_TYPE(&PyCFuncPtr_Type, &PyCFuncPtrType_Type, &PyCData_Type); + + /************************************************* + * + * Simple classes + */ + + CREATE_TYPE(mod, st->PyCField_Type, &cfield_spec, NULL); + + /************************************************* + * + * Other stuff + */ + + CREATE_TYPE(mod, st->DictRemover_Type, &dictremover_spec, NULL); + CREATE_TYPE(mod, st->StructParam_Type, &structparam_spec, NULL); + +#ifdef MS_WIN32 + CREATE_TYPE(mod, st->PyComError_Type, &comerror_spec, PyExc_Exception); +#endif + +#undef TYPE_READY +#undef TYPE_READY_BASE +#undef MOD_ADD_TYPE +#undef CREATE_TYPE + return 0; +} + + +static int +_ctypes_add_objects(PyObject *mod) +{ +#define MOD_ADD(name, expr) \ + do { \ + PyObject *obj = (expr); \ + if (obj == NULL) { \ + return -1; \ + } \ + if (PyModule_AddObjectRef(mod, name, obj) < 0) { \ + Py_DECREF(obj); \ + return -1; \ + } \ + Py_DECREF(obj); \ + } while (0) + + MOD_ADD("_pointer_type_cache", Py_NewRef(_ctypes_ptrtype_cache)); + +#ifdef MS_WIN32 + ctypes_state *st = GLOBAL_STATE(); + MOD_ADD("COMError", Py_NewRef(st->PyComError_Type)); + MOD_ADD("FUNCFLAG_HRESULT", PyLong_FromLong(FUNCFLAG_HRESULT)); + MOD_ADD("FUNCFLAG_STDCALL", PyLong_FromLong(FUNCFLAG_STDCALL)); +#endif + MOD_ADD("FUNCFLAG_CDECL", PyLong_FromLong(FUNCFLAG_CDECL)); + MOD_ADD("FUNCFLAG_USE_ERRNO", PyLong_FromLong(FUNCFLAG_USE_ERRNO)); + MOD_ADD("FUNCFLAG_USE_LASTERROR", PyLong_FromLong(FUNCFLAG_USE_LASTERROR)); + MOD_ADD("FUNCFLAG_PYTHONAPI", PyLong_FromLong(FUNCFLAG_PYTHONAPI)); + MOD_ADD("__version__", PyUnicode_FromString("1.1.0")); + + MOD_ADD("_memmove_addr", PyLong_FromVoidPtr(memmove)); + MOD_ADD("_memset_addr", PyLong_FromVoidPtr(memset)); + MOD_ADD("_string_at_addr", PyLong_FromVoidPtr(string_at)); + MOD_ADD("_cast_addr", PyLong_FromVoidPtr(cast)); + MOD_ADD("_wstring_at_addr", PyLong_FromVoidPtr(wstring_at)); + +/* If RTLD_LOCAL is not defined (Windows!), set it to zero. */ +#if !HAVE_DECL_RTLD_LOCAL +# define RTLD_LOCAL 0 +#endif + +/* If RTLD_GLOBAL is not defined (cygwin), set it to the same value as + RTLD_LOCAL. */ +#if !HAVE_DECL_RTLD_GLOBAL +# define RTLD_GLOBAL RTLD_LOCAL +#endif + MOD_ADD("RTLD_LOCAL", PyLong_FromLong(RTLD_LOCAL)); + MOD_ADD("RTLD_GLOBAL", PyLong_FromLong(RTLD_GLOBAL)); + MOD_ADD("CTYPES_MAX_ARGCOUNT", PyLong_FromLong(CTYPES_MAX_ARGCOUNT)); + MOD_ADD("ArgumentError", Py_NewRef(PyExc_ArgError)); + MOD_ADD("SIZEOF_TIME_T", PyLong_FromSsize_t(SIZEOF_TIME_T)); + return 0; +#undef MOD_ADD +} + + +static int +_ctypes_mod_exec(PyObject *mod) +{ + _unpickle = PyObject_GetAttrString(mod, "_unpickle"); + if (_unpickle == NULL) { + return -1; + } + + _ctypes_ptrtype_cache = PyDict_New(); + if (_ctypes_ptrtype_cache == NULL) { + return -1; + } + + PyExc_ArgError = PyErr_NewException("ctypes.ArgumentError", NULL, NULL); + if (!PyExc_ArgError) { + return -1; + } + + if (_ctypes_add_types(mod) < 0) { + return -1; + } + + if (_ctypes_add_objects(mod) < 0) { + return -1; + } + return 0; +} + + +PyMODINIT_FUNC +PyInit__ctypes(void) +{ + PyObject *mod = PyModule_Create(&_ctypesmodule); + if (!mod) { + return NULL; + } + + if (_ctypes_mod_exec(mod) < 0) { + Py_DECREF(mod); + return NULL; + } + return mod; +} + +/* + Local Variables: + compile-command: "cd .. && python setup.py -q build -g && python setup.py -q build install --home ~" + End: +*/ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.c similarity index 99% rename from graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.c rename to graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.c index 91150d4b3a..8f8241968e 100644 --- a/graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.c +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.c @@ -1,5 +1,5 @@ -/* Copyright (c) 2021, 2024, Oracle and/or its affiliates. - * Copyright (C) 1996-2020 Python Software Foundation +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 */ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.h b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.h new file mode 100644 index 0000000000..c76f18c088 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/_ctypes_test.h @@ -0,0 +1,6 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +extern int _testfunc_i_bhilfd(char b, short h, int i, long l, float f, double d); diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callbacks.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callbacks.c new file mode 100644 index 0000000000..4d5917c78e --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callbacks.c @@ -0,0 +1,617 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif + +#include "Python.h" +// windows.h must be included before pycore internal headers +#ifdef MS_WIN32 +# include +#endif + +#include "pycore_call.h" // _PyObject_CallNoArgs() +#include "pycore_runtime.h" // _PyRuntime +#include "pycore_global_objects.h" // _Py_ID() + +#include + +#ifdef MS_WIN32 +# include +#endif + +#include +#include "ctypes.h" + +#ifdef HAVE_ALLOCA_H +/* AIX needs alloca.h for alloca() */ +#include +#endif + +/**************************************************************/ + +static int +CThunkObject_traverse(PyObject *myself, visitproc visit, void *arg) +{ + CThunkObject *self = (CThunkObject *)myself; + Py_VISIT(Py_TYPE(self)); + Py_VISIT(self->converters); + Py_VISIT(self->callable); + Py_VISIT(self->restype); + return 0; +} + +static int +CThunkObject_clear(PyObject *myself) +{ + CThunkObject *self = (CThunkObject *)myself; + Py_CLEAR(self->converters); + Py_CLEAR(self->callable); + Py_CLEAR(self->restype); + return 0; +} + +static void +CThunkObject_dealloc(PyObject *myself) +{ + CThunkObject *self = (CThunkObject *)myself; + PyTypeObject *tp = Py_TYPE(myself); + PyObject_GC_UnTrack(self); + (void)CThunkObject_clear(myself); + if (self->pcl_write) { + Py_ffi_closure_free(self->pcl_write); + } + PyObject_GC_Del(self); + Py_DECREF(tp); +} + +static PyType_Slot cthunk_slots[] = { + {Py_tp_doc, (void *)PyDoc_STR("CThunkObject")}, + {Py_tp_dealloc, CThunkObject_dealloc}, + {Py_tp_traverse, CThunkObject_traverse}, + {Py_tp_clear, CThunkObject_clear}, + {0, NULL}, +}; + +PyType_Spec cthunk_spec = { + .name = "_ctypes.CThunkObject", + .basicsize = sizeof(CThunkObject), + .itemsize = sizeof(ffi_type), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), + .slots = cthunk_slots, +}; + +/**************************************************************/ + +static void +PrintError(const char *msg, ...) +{ + char buf[512]; + PyObject *f = PySys_GetObject("stderr"); + va_list marker; + + va_start(marker, msg); + PyOS_vsnprintf(buf, sizeof(buf), msg, marker); + va_end(marker); + if (f != NULL && f != Py_None) + PyFile_WriteString(buf, f); + PyErr_Print(); +} + + +#ifdef MS_WIN32 +/* + * We must call AddRef() on non-NULL COM pointers we receive as arguments + * to callback functions - these functions are COM method implementations. + * The Python instances we create have a __del__ method which calls Release(). + * + * The presence of a class attribute named '_needs_com_addref_' triggers this + * behaviour. It would also be possible to call the AddRef() Python method, + * after checking for PyObject_IsTrue(), but this would probably be somewhat + * slower. + */ +static void +TryAddRef(StgDictObject *dict, CDataObject *obj) +{ + IUnknown *punk; + int r = PyDict_Contains((PyObject *)dict, _Py_ID(_needs_com_addref_)); + if (r <= 0) { + if (r < 0) { + PrintError("getting _needs_com_addref_"); + } + return; + } + + punk = *(IUnknown **)obj->b_ptr; + if (punk) + punk->lpVtbl->AddRef(punk); + return; +} +#endif + +/****************************************************************************** + * + * Call the python object with all arguments + * + */ +static void _CallPythonObject(void *mem, + ffi_type *restype, + SETFUNC setfunc, + PyObject *callable, + PyObject *converters, + int flags, + void **pArgs) +{ + PyObject *result = NULL; + Py_ssize_t i = 0, j = 0, nargs = 0; + PyObject *error_object = NULL; + int *space; + PyGILState_STATE state = PyGILState_Ensure(); + + assert(PyTuple_Check(converters)); + nargs = PyTuple_GET_SIZE(converters); + assert(nargs <= CTYPES_MAX_ARGCOUNT); + PyObject **args = alloca(nargs * sizeof(PyObject *)); + PyObject **cnvs = PySequence_Fast_ITEMS(converters); + for (i = 0; i < nargs; i++) { + PyObject *cnv = cnvs[i]; // borrowed ref + StgDictObject *dict; + dict = PyType_stgdict(cnv); + + if (dict && dict->getfunc && !_ctypes_simple_instance(cnv)) { + PyObject *v = dict->getfunc(*pArgs, dict->size); + if (!v) { + PrintError("create argument %zd:\n", i); + goto Done; + } + args[i] = v; + /* XXX XXX XX + We have the problem that c_byte or c_short have dict->size of + 1 resp. 4, but these parameters are pushed as sizeof(int) bytes. + BTW, the same problem occurs when they are pushed as parameters + */ + } else if (dict) { + /* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */ + CDataObject *obj = (CDataObject *)_PyObject_CallNoArgs(cnv); + if (!obj) { + PrintError("create argument %zd:\n", i); + goto Done; + } + if (!CDataObject_Check(obj)) { + Py_DECREF(obj); + PrintError("unexpected result of create argument %zd:\n", i); + goto Done; + } + memcpy(obj->b_ptr, *pArgs, dict->size); + args[i] = (PyObject *)obj; +#ifdef MS_WIN32 + TryAddRef(dict, obj); +#endif + } else { + PyErr_SetString(PyExc_TypeError, + "cannot build parameter"); + PrintError("Parsing argument %zd\n", i); + goto Done; + } + /* XXX error handling! */ + pArgs++; + } + + if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) { + error_object = _ctypes_get_errobj(&space); + if (error_object == NULL) + goto Done; + if (flags & FUNCFLAG_USE_ERRNO) { + int temp = space[0]; + space[0] = errno; + errno = temp; + } +#ifdef MS_WIN32 + if (flags & FUNCFLAG_USE_LASTERROR) { + int temp = space[1]; + space[1] = GetLastError(); + SetLastError(temp); + } +#endif + } + + result = PyObject_Vectorcall(callable, args, nargs, NULL); + if (result == NULL) { + _PyErr_WriteUnraisableMsg("on calling ctypes callback function", + callable); + } + +#ifdef MS_WIN32 + if (flags & FUNCFLAG_USE_LASTERROR) { + int temp = space[1]; + space[1] = GetLastError(); + SetLastError(temp); + } +#endif + if (flags & FUNCFLAG_USE_ERRNO) { + int temp = space[0]; + space[0] = errno; + errno = temp; + } + Py_XDECREF(error_object); + + if (restype != &ffi_type_void && result) { + assert(setfunc); + +#ifdef WORDS_BIGENDIAN + /* See the corresponding code in _ctypes_callproc(): + in callproc.c, around line 1219. */ + if (restype->type != FFI_TYPE_FLOAT && restype->size < sizeof(ffi_arg)) { + mem = (char *)mem + sizeof(ffi_arg) - restype->size; + } +#endif + + /* keep is an object we have to keep alive so that the result + stays valid. If there is no such object, the setfunc will + have returned Py_None. + + If there is such an object, we have no choice than to keep + it alive forever - but a refcount and/or memory leak will + be the result. EXCEPT when restype is py_object - Python + itself knows how to manage the refcount of these objects. + */ + PyObject *keep = setfunc(mem, result, 0); + + if (keep == NULL) { + /* Could not convert callback result. */ + _PyErr_WriteUnraisableMsg("on converting result " + "of ctypes callback function", + callable); + } + else if (setfunc != _ctypes_get_fielddesc("O")->setfunc) { + if (keep == Py_None) { + /* Nothing to keep */ + Py_DECREF(keep); + } + else if (PyErr_WarnEx(PyExc_RuntimeWarning, + "memory leak in callback function.", + 1) == -1) { + _PyErr_WriteUnraisableMsg("on converting result " + "of ctypes callback function", + callable); + } + } + } + + Py_XDECREF(result); + + Done: + for (j = 0; j < i; j++) { + Py_DECREF(args[j]); + } + PyGILState_Release(state); +} + +static void closure_fcn(ffi_cif *cif, + void *resp, + void **args, + void *userdata) +{ + CThunkObject *p = (CThunkObject *)userdata; + + _CallPythonObject(resp, + p->ffi_restype, + p->setfunc, + p->callable, + p->converters, + p->flags, + args); +} + +static CThunkObject* CThunkObject_new(Py_ssize_t nargs) +{ + CThunkObject *p; + Py_ssize_t i; + + ctypes_state *st = GLOBAL_STATE(); + p = PyObject_GC_NewVar(CThunkObject, st->PyCThunk_Type, nargs); + if (p == NULL) { + return NULL; + } + + p->pcl_write = NULL; + p->pcl_exec = NULL; + memset(&p->cif, 0, sizeof(p->cif)); + p->flags = 0; + p->converters = NULL; + p->callable = NULL; + p->restype = NULL; + p->setfunc = NULL; + p->ffi_restype = NULL; + + for (i = 0; i < nargs + 1; ++i) + p->atypes[i] = NULL; + PyObject_GC_Track((PyObject *)p); + return p; +} + +CThunkObject *_ctypes_alloc_callback(PyObject *callable, + PyObject *converters, + PyObject *restype, + int flags) +{ + int result; + CThunkObject *p; + Py_ssize_t nargs, i; + ffi_abi cc; + + assert(PyTuple_Check(converters)); + nargs = PyTuple_GET_SIZE(converters); + p = CThunkObject_new(nargs); + if (p == NULL) + return NULL; + +#ifdef Py_DEBUG + ctypes_state *st = GLOBAL_STATE(); + assert(CThunk_CheckExact(st, (PyObject *)p)); +#endif + + p->pcl_write = Py_ffi_closure_alloc(sizeof(ffi_closure), &p->pcl_exec); + if (p->pcl_write == NULL) { + PyErr_NoMemory(); + goto error; + } + + p->flags = flags; + PyObject **cnvs = PySequence_Fast_ITEMS(converters); + for (i = 0; i < nargs; ++i) { + PyObject *cnv = cnvs[i]; // borrowed ref + p->atypes[i] = _ctypes_get_ffi_type(cnv); + } + p->atypes[i] = NULL; + + p->restype = Py_NewRef(restype); + if (restype == Py_None) { + p->setfunc = NULL; + p->ffi_restype = &ffi_type_void; + } else { + StgDictObject *dict = PyType_stgdict(restype); + if (dict == NULL || dict->setfunc == NULL) { + PyErr_SetString(PyExc_TypeError, + "invalid result type for callback function"); + goto error; + } + p->setfunc = dict->setfunc; + p->ffi_restype = &dict->ffi_type_pointer; + } + + cc = FFI_DEFAULT_ABI; +#if defined(MS_WIN32) && !defined(_WIN32_WCE) && !defined(MS_WIN64) && !defined(_M_ARM) + if ((flags & FUNCFLAG_CDECL) == 0) + cc = FFI_STDCALL; +#endif + result = ffi_prep_cif(&p->cif, cc, + Py_SAFE_DOWNCAST(nargs, Py_ssize_t, int), + p->ffi_restype, + &p->atypes[0]); + if (result != FFI_OK) { + PyErr_Format(PyExc_RuntimeError, + "ffi_prep_cif failed with %d", result); + goto error; + } + + +#if HAVE_FFI_PREP_CLOSURE_LOC +# ifdef USING_APPLE_OS_LIBFFI +# ifdef HAVE_BUILTIN_AVAILABLE +# define HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME __builtin_available(macos 10.15, ios 13, watchos 6, tvos 13, *) +# else +# define HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME (ffi_prep_closure_loc != NULL) +# endif +# else +# define HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME 1 +# endif + if (HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME) { + result = ffi_prep_closure_loc(p->pcl_write, &p->cif, closure_fcn, + p, + p->pcl_exec); + } else +#endif + { +#if defined(USING_APPLE_OS_LIBFFI) && defined(__arm64__) + PyErr_Format(PyExc_NotImplementedError, "ffi_prep_closure_loc() is missing"); + goto error; +#else +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#endif + result = ffi_prep_closure(p->pcl_write, &p->cif, closure_fcn, p); + +#if defined(__clang__) + #pragma clang diagnostic pop +#endif +#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))) + #pragma GCC diagnostic pop +#endif + +#endif + } + if (result != FFI_OK) { + PyErr_Format(PyExc_RuntimeError, + "ffi_prep_closure failed with %d", result); + goto error; + } + + p->converters = Py_NewRef(converters); + p->callable = Py_NewRef(callable); + return p; + + error: + Py_XDECREF(p); + return NULL; +} + +#ifdef MS_WIN32 + +static void LoadPython(void) +{ + if (!Py_IsInitialized()) { + Py_Initialize(); + } +} + +/******************************************************************/ + +long Call_GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) +{ + PyObject *func, *result; + long retval; + static PyObject *context; + + if (context == NULL) + context = PyUnicode_InternFromString("_ctypes.DllGetClassObject"); + + func = _PyImport_GetModuleAttrString("ctypes", "DllGetClassObject"); + if (!func) { + PyErr_WriteUnraisable(context ? context : Py_None); + /* There has been a warning before about this already */ + return E_FAIL; + } + + { + PyObject *py_rclsid = PyLong_FromVoidPtr((void *)rclsid); + if (py_rclsid == NULL) { + Py_DECREF(func); + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + PyObject *py_riid = PyLong_FromVoidPtr((void *)riid); + if (py_riid == NULL) { + Py_DECREF(func); + Py_DECREF(py_rclsid); + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + PyObject *py_ppv = PyLong_FromVoidPtr(ppv); + if (py_ppv == NULL) { + Py_DECREF(py_rclsid); + Py_DECREF(py_riid); + Py_DECREF(func); + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + result = PyObject_CallFunctionObjArgs(func, + py_rclsid, + py_riid, + py_ppv, + NULL); + Py_DECREF(py_rclsid); + Py_DECREF(py_riid); + Py_DECREF(py_ppv); + } + Py_DECREF(func); + if (!result) { + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + + retval = PyLong_AsLong(result); + if (PyErr_Occurred()) { + PyErr_WriteUnraisable(context ? context : Py_None); + retval = E_FAIL; + } + Py_DECREF(result); + return retval; +} + +STDAPI DllGetClassObject(REFCLSID rclsid, + REFIID riid, + LPVOID *ppv) +{ + long result; + PyGILState_STATE state; + + LoadPython(); + state = PyGILState_Ensure(); + result = Call_GetClassObject(rclsid, riid, ppv); + PyGILState_Release(state); + return result; +} + +long Call_CanUnloadNow(void) +{ + PyObject *mod, *func, *result; + long retval; + static PyObject *context; + + if (context == NULL) + context = PyUnicode_InternFromString("_ctypes.DllCanUnloadNow"); + + mod = PyImport_ImportModule("ctypes"); + if (!mod) { +/* OutputDebugString("Could not import ctypes"); */ + /* We assume that this error can only occur when shutting + down, so we silently ignore it */ + PyErr_Clear(); + return E_FAIL; + } + /* Other errors cannot be raised, but are printed to stderr */ + func = PyObject_GetAttrString(mod, "DllCanUnloadNow"); + Py_DECREF(mod); + if (!func) { + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + + result = _PyObject_CallNoArgs(func); + Py_DECREF(func); + if (!result) { + PyErr_WriteUnraisable(context ? context : Py_None); + return E_FAIL; + } + + retval = PyLong_AsLong(result); + if (PyErr_Occurred()) { + PyErr_WriteUnraisable(context ? context : Py_None); + retval = E_FAIL; + } + Py_DECREF(result); + return retval; +} + +/* + DllRegisterServer and DllUnregisterServer still missing +*/ + +STDAPI DllCanUnloadNow(void) +{ + long result; + PyGILState_STATE state = PyGILState_Ensure(); + result = Call_CanUnloadNow(); + PyGILState_Release(state); + return result; +} + +#ifndef Py_NO_ENABLE_SHARED +BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvRes) +{ + switch(fdwReason) { + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hinstDLL); + break; + } + return TRUE; +} +#endif + +#endif + +/* + Local Variables: + compile-command: "cd .. && python setup.py -q build_ext" + End: +*/ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callproc.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callproc.c new file mode 100644 index 0000000000..cc02cfa9be --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/callproc.c @@ -0,0 +1,2043 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +/* + * History: First version dated from 3/97, derived from my SCMLIB version + * for win16. + */ +/* + * Related Work: + * - calldll http://www.nightmare.com/software.html + * - libffi http://sourceware.cygnus.com/libffi/ + * - ffcall http://clisp.cons.org/~haible/packages-ffcall.html + * and, of course, Don Beaudry's MESS package, but this is more ctypes + * related. + */ + + +/* + How are functions called, and how are parameters converted to C ? + + 1. _ctypes.c::PyCFuncPtr_call receives an argument tuple 'inargs' and a + keyword dictionary 'kwds'. + + 2. After several checks, _build_callargs() is called which returns another + tuple 'callargs'. This may be the same tuple as 'inargs', a slice of + 'inargs', or a completely fresh tuple, depending on several things (is it a + COM method?, are 'paramflags' available?). + + 3. _build_callargs also calculates bitarrays containing indexes into + the callargs tuple, specifying how to build the return value(s) of + the function. + + 4. _ctypes_callproc is then called with the 'callargs' tuple. _ctypes_callproc first + allocates two arrays. The first is an array of 'struct argument' items, the + second array has 'void *' entries. + + 5. If 'converters' are present (converters is a sequence of argtypes' + from_param methods), for each item in 'callargs' converter is called and the + result passed to ConvParam. If 'converters' are not present, each argument + is directly passed to ConvParm. + + 6. For each arg, ConvParam stores the contained C data (or a pointer to it, + for structures) into the 'struct argument' array. + + 7. Finally, a loop fills the 'void *' array so that each item points to the + data contained in or pointed to by the 'struct argument' array. + + 8. The 'void *' argument array is what _call_function_pointer + expects. _call_function_pointer then has very little to do - only some + libffi specific stuff, then it calls ffi_call. + + So, there are 4 data structures holding processed arguments: + - the inargs tuple (in PyCFuncPtr_call) + - the callargs tuple (in PyCFuncPtr_call) + - the 'struct arguments' array + - the 'void *' array + + */ + +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif + +#include "Python.h" +#include "structmember.h" // PyMemberDef + +#include + +#ifdef MS_WIN32 +#include +#include +#else +#include +#endif + +#ifdef __APPLE__ +#include +#endif + +#ifdef MS_WIN32 +#include +#endif + +#include +#include "ctypes.h" +#ifdef HAVE_ALLOCA_H +/* AIX needs alloca.h for alloca() */ +#include +#endif + +#ifdef _Py_MEMORY_SANITIZER +#include +#endif + +#if defined(_DEBUG) || defined(__MINGW32__) +/* Don't use structured exception handling on Windows if this is defined. + MingW, AFAIK, doesn't support it. +*/ +#define DONT_USE_SEH +#endif + +#include "pycore_runtime.h" // _PyRuntime +#include "pycore_global_objects.h" // _Py_ID() + +#define CTYPES_CAPSULE_NAME_PYMEM "_ctypes pymem" + + +static void pymem_destructor(PyObject *ptr) +{ + void *p = PyCapsule_GetPointer(ptr, CTYPES_CAPSULE_NAME_PYMEM); + if (p) { + PyMem_Free(p); + } +} + +/* + ctypes maintains thread-local storage that has space for two error numbers: + private copies of the system 'errno' value and, on Windows, the system error code + accessed by the GetLastError() and SetLastError() api functions. + + Foreign functions created with CDLL(..., use_errno=True), when called, swap + the system 'errno' value with the private copy just before the actual + function call, and swapped again immediately afterwards. The 'use_errno' + parameter defaults to False, in this case 'ctypes_errno' is not touched. + + On Windows, foreign functions created with CDLL(..., use_last_error=True) or + WinDLL(..., use_last_error=True) swap the system LastError value with the + ctypes private copy. + + The values are also swapped immediately before and after ctypes callback + functions are called, if the callbacks are constructed using the new + optional use_errno parameter set to True: CFUNCTYPE(..., use_errno=TRUE) or + WINFUNCTYPE(..., use_errno=True). + + New ctypes functions are provided to access the ctypes private copies from + Python: + + - ctypes.set_errno(value) and ctypes.set_last_error(value) store 'value' in + the private copy and returns the previous value. + + - ctypes.get_errno() and ctypes.get_last_error() returns the current ctypes + private copies value. +*/ + +/* + This function creates and returns a thread-local Python object that has + space to store two integer error numbers; once created the Python object is + kept alive in the thread state dictionary as long as the thread itself. +*/ +PyObject * +_ctypes_get_errobj(int **pspace) +{ + PyObject *dict = PyThreadState_GetDict(); + PyObject *errobj; + static PyObject *error_object_name; + if (dict == NULL) { + PyErr_SetString(PyExc_RuntimeError, + "cannot get thread state"); + return NULL; + } + if (error_object_name == NULL) { + error_object_name = PyUnicode_InternFromString("ctypes.error_object"); + if (error_object_name == NULL) + return NULL; + } + errobj = PyDict_GetItemWithError(dict, error_object_name); + if (errobj) { + if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_NAME_PYMEM)) { + PyErr_SetString(PyExc_RuntimeError, + "ctypes.error_object is an invalid capsule"); + return NULL; + } + Py_INCREF(errobj); + } + else if (!PyErr_Occurred()) { + void *space = PyMem_Calloc(2, sizeof(int)); + if (space == NULL) + return NULL; + errobj = PyCapsule_New(space, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor); + if (errobj == NULL) { + PyMem_Free(space); + return NULL; + } + if (-1 == PyDict_SetItem(dict, error_object_name, + errobj)) { + Py_DECREF(errobj); + return NULL; + } + } + else { + return NULL; + } + *pspace = (int *)PyCapsule_GetPointer(errobj, CTYPES_CAPSULE_NAME_PYMEM); + return errobj; +} + +static PyObject * +get_error_internal(PyObject *self, PyObject *args, int index) +{ + int *space; + PyObject *errobj = _ctypes_get_errobj(&space); + PyObject *result; + + if (errobj == NULL) + return NULL; + result = PyLong_FromLong(space[index]); + Py_DECREF(errobj); + return result; +} + +static PyObject * +set_error_internal(PyObject *self, PyObject *args, int index) +{ + int new_errno, old_errno; + PyObject *errobj; + int *space; + + if (!PyArg_ParseTuple(args, "i", &new_errno)) { + return NULL; + } + errobj = _ctypes_get_errobj(&space); + if (errobj == NULL) + return NULL; + old_errno = space[index]; + space[index] = new_errno; + Py_DECREF(errobj); + return PyLong_FromLong(old_errno); +} + +static PyObject * +get_errno(PyObject *self, PyObject *args) +{ + if (PySys_Audit("ctypes.get_errno", NULL) < 0) { + return NULL; + } + return get_error_internal(self, args, 0); +} + +static PyObject * +set_errno(PyObject *self, PyObject *args) +{ + if (PySys_Audit("ctypes.set_errno", "O", args) < 0) { + return NULL; + } + return set_error_internal(self, args, 0); +} + +#ifdef MS_WIN32 + +static PyObject * +get_last_error(PyObject *self, PyObject *args) +{ + if (PySys_Audit("ctypes.get_last_error", NULL) < 0) { + return NULL; + } + return get_error_internal(self, args, 1); +} + +static PyObject * +set_last_error(PyObject *self, PyObject *args) +{ + if (PySys_Audit("ctypes.set_last_error", "O", args) < 0) { + return NULL; + } + return set_error_internal(self, args, 1); +} + +static WCHAR *FormatError(DWORD code) +{ + WCHAR *lpMsgBuf; + DWORD n; + n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + code, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ + (LPWSTR) &lpMsgBuf, + 0, + NULL); + if (n) { + while (iswspace(lpMsgBuf[n-1])) + --n; + lpMsgBuf[n] = L'\0'; /* rstrip() */ + } + return lpMsgBuf; +} + +#ifndef DONT_USE_SEH +static void SetException(DWORD code, EXCEPTION_RECORD *pr) +{ + if (PySys_Audit("ctypes.set_exception", "I", code) < 0) { + /* An exception was set by the audit hook */ + return; + } + + /* The 'code' is a normal win32 error code so it could be handled by + PyErr_SetFromWindowsErr(). However, for some errors, we have additional + information not included in the error code. We handle those here and + delegate all others to the generic function. */ + switch (code) { + case EXCEPTION_ACCESS_VIOLATION: + /* The thread attempted to read from or write + to a virtual address for which it does not + have the appropriate access. */ + if (pr->ExceptionInformation[0] == 0) + PyErr_Format(PyExc_OSError, + "exception: access violation reading %p", + pr->ExceptionInformation[1]); + else + PyErr_Format(PyExc_OSError, + "exception: access violation writing %p", + pr->ExceptionInformation[1]); + break; + + case EXCEPTION_BREAKPOINT: + /* A breakpoint was encountered. */ + PyErr_SetString(PyExc_OSError, + "exception: breakpoint encountered"); + break; + + case EXCEPTION_DATATYPE_MISALIGNMENT: + /* The thread attempted to read or write data that is + misaligned on hardware that does not provide + alignment. For example, 16-bit values must be + aligned on 2-byte boundaries, 32-bit values on + 4-byte boundaries, and so on. */ + PyErr_SetString(PyExc_OSError, + "exception: datatype misalignment"); + break; + + case EXCEPTION_SINGLE_STEP: + /* A trace trap or other single-instruction mechanism + signaled that one instruction has been executed. */ + PyErr_SetString(PyExc_OSError, + "exception: single step"); + break; + + case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: + /* The thread attempted to access an array element + that is out of bounds, and the underlying hardware + supports bounds checking. */ + PyErr_SetString(PyExc_OSError, + "exception: array bounds exceeded"); + break; + + case EXCEPTION_FLT_DENORMAL_OPERAND: + /* One of the operands in a floating-point operation + is denormal. A denormal value is one that is too + small to represent as a standard floating-point + value. */ + PyErr_SetString(PyExc_OSError, + "exception: floating-point operand denormal"); + break; + + case EXCEPTION_FLT_DIVIDE_BY_ZERO: + /* The thread attempted to divide a floating-point + value by a floating-point divisor of zero. */ + PyErr_SetString(PyExc_OSError, + "exception: float divide by zero"); + break; + + case EXCEPTION_FLT_INEXACT_RESULT: + /* The result of a floating-point operation cannot be + represented exactly as a decimal fraction. */ + PyErr_SetString(PyExc_OSError, + "exception: float inexact"); + break; + + case EXCEPTION_FLT_INVALID_OPERATION: + /* This exception represents any floating-point + exception not included in this list. */ + PyErr_SetString(PyExc_OSError, + "exception: float invalid operation"); + break; + + case EXCEPTION_FLT_OVERFLOW: + /* The exponent of a floating-point operation is + greater than the magnitude allowed by the + corresponding type. */ + PyErr_SetString(PyExc_OSError, + "exception: float overflow"); + break; + + case EXCEPTION_FLT_STACK_CHECK: + /* The stack overflowed or underflowed as the result + of a floating-point operation. */ + PyErr_SetString(PyExc_OSError, + "exception: stack over/underflow"); + break; + + case EXCEPTION_STACK_OVERFLOW: + /* The stack overflowed or underflowed as the result + of a floating-point operation. */ + PyErr_SetString(PyExc_OSError, + "exception: stack overflow"); + break; + + case EXCEPTION_FLT_UNDERFLOW: + /* The exponent of a floating-point operation is less + than the magnitude allowed by the corresponding + type. */ + PyErr_SetString(PyExc_OSError, + "exception: float underflow"); + break; + + case EXCEPTION_INT_DIVIDE_BY_ZERO: + /* The thread attempted to divide an integer value by + an integer divisor of zero. */ + PyErr_SetString(PyExc_OSError, + "exception: integer divide by zero"); + break; + + case EXCEPTION_INT_OVERFLOW: + /* The result of an integer operation caused a carry + out of the most significant bit of the result. */ + PyErr_SetString(PyExc_OSError, + "exception: integer overflow"); + break; + + case EXCEPTION_PRIV_INSTRUCTION: + /* The thread attempted to execute an instruction + whose operation is not allowed in the current + machine mode. */ + PyErr_SetString(PyExc_OSError, + "exception: privileged instruction"); + break; + + case EXCEPTION_NONCONTINUABLE_EXCEPTION: + /* The thread attempted to continue execution after a + noncontinuable exception occurred. */ + PyErr_SetString(PyExc_OSError, + "exception: nocontinuable"); + break; + + default: + PyErr_SetFromWindowsErr(code); + break; + } +} + +static DWORD HandleException(EXCEPTION_POINTERS *ptrs, + DWORD *pdw, EXCEPTION_RECORD *record) +{ + *pdw = ptrs->ExceptionRecord->ExceptionCode; + *record = *ptrs->ExceptionRecord; + /* We don't want to catch breakpoint exceptions, they are used to attach + * a debugger to the process. + */ + if (*pdw == EXCEPTION_BREAKPOINT) + return EXCEPTION_CONTINUE_SEARCH; + return EXCEPTION_EXECUTE_HANDLER; +} +#endif + +static PyObject * +check_hresult(PyObject *self, PyObject *args) +{ + HRESULT hr; + if (!PyArg_ParseTuple(args, "i", &hr)) + return NULL; + if (FAILED(hr)) + return PyErr_SetFromWindowsErr(hr); + return PyLong_FromLong(hr); +} + +#endif + +/**************************************************************/ + +PyCArgObject * +PyCArgObject_new(void) +{ + PyCArgObject *p; + ctypes_state *st = GLOBAL_STATE(); + p = PyObject_GC_New(PyCArgObject, st->PyCArg_Type); + if (p == NULL) + return NULL; + p->pffi_type = NULL; + p->tag = '\0'; + p->obj = NULL; + memset(&p->value, 0, sizeof(p->value)); + PyObject_GC_Track(p); + return p; +} + +static int +PyCArg_traverse(PyCArgObject *self, visitproc visit, void *arg) +{ + Py_VISIT(Py_TYPE(self)); + Py_VISIT(self->obj); + return 0; +} + +static int +PyCArg_clear(PyCArgObject *self) +{ + Py_CLEAR(self->obj); + return 0; +} + +static void +PyCArg_dealloc(PyCArgObject *self) +{ + PyTypeObject *tp = Py_TYPE(self); + PyObject_GC_UnTrack(self); + (void)PyCArg_clear(self); + tp->tp_free((PyObject *)self); + Py_DECREF(tp); +} + +static int +is_literal_char(unsigned char c) +{ + return c < 128 && _PyUnicode_IsPrintable(c) && c != '\\' && c != '\''; +} + +static PyObject * +PyCArg_repr(PyCArgObject *self) +{ + switch(self->tag) { + case 'b': + case 'B': + return PyUnicode_FromFormat("", + self->tag, self->value.b); + case 'h': + case 'H': + return PyUnicode_FromFormat("", + self->tag, self->value.h); + case 'i': + case 'I': + return PyUnicode_FromFormat("", + self->tag, self->value.i); + case 'l': + case 'L': + return PyUnicode_FromFormat("", + self->tag, self->value.l); + + case 'q': + case 'Q': + return PyUnicode_FromFormat("", + self->tag, self->value.q); + case 'd': + case 'f': { + PyObject *f = PyFloat_FromDouble((self->tag == 'f') ? self->value.f : self->value.d); + if (f == NULL) { + return NULL; + } + PyObject *result = PyUnicode_FromFormat("", self->tag, f); + Py_DECREF(f); + return result; + } + case 'c': + if (is_literal_char((unsigned char)self->value.c)) { + return PyUnicode_FromFormat("", + self->tag, self->value.c); + } + else { + return PyUnicode_FromFormat("", + self->tag, (unsigned char)self->value.c); + } + +/* Hm, are these 'z' and 'Z' codes useful at all? + Shouldn't they be replaced by the functionality of create_string_buffer() + and c_wstring() ? +*/ + case 'z': + case 'Z': + case 'P': + return PyUnicode_FromFormat("", + self->tag, self->value.p); + break; + + default: + if (is_literal_char((unsigned char)self->tag)) { + return PyUnicode_FromFormat("", + (unsigned char)self->tag, (void *)self); + } + else { + return PyUnicode_FromFormat("", + (unsigned char)self->tag, (void *)self); + } + } +} + +static PyMemberDef PyCArgType_members[] = { + { "_obj", T_OBJECT, + offsetof(PyCArgObject, obj), READONLY, + "the wrapped object" }, + { NULL }, +}; + +static PyType_Slot carg_slots[] = { + {Py_tp_dealloc, PyCArg_dealloc}, + {Py_tp_traverse, PyCArg_traverse}, + {Py_tp_clear, PyCArg_clear}, + {Py_tp_repr, PyCArg_repr}, + {Py_tp_members, PyCArgType_members}, + {0, NULL}, +}; + +PyType_Spec carg_spec = { + .name = "_ctypes.CArgObject", + .basicsize = sizeof(PyCArgObject), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), + .slots = carg_slots, +}; + +/****************************************************************/ +/* + * Convert a PyObject * into a parameter suitable to pass to an + * C function call. + * + * 1. Python integers are converted to C int and passed by value. + * Py_None is converted to a C NULL pointer. + * + * 2. 3-tuples are expected to have a format character in the first + * item, which must be 'i', 'f', 'd', 'q', or 'P'. + * The second item will have to be an integer, float, double, long long + * or integer (denoting an address void *), will be converted to the + * corresponding C data type and passed by value. + * + * 3. Other Python objects are tested for an '_as_parameter_' attribute. + * The value of this attribute must be an integer which will be passed + * by value, or a 2-tuple or 3-tuple which will be used according + * to point 2 above. The third item (if any), is ignored. It is normally + * used to keep the object alive where this parameter refers to. + * XXX This convention is dangerous - you can construct arbitrary tuples + * in Python and pass them. Would it be safer to use a custom container + * datatype instead of a tuple? + * + * 4. Other Python objects cannot be passed as parameters - an exception is raised. + * + * 5. ConvParam will store the converted result in a struct containing format + * and value. + */ + +union result { + char c; + char b; + short h; + int i; + long l; + long long q; + long double D; + double d; + float f; + void *p; +}; + +struct argument { + ffi_type *ffi_type; + PyObject *keep; + union result value; +}; + +/* + * Convert a single Python object into a PyCArgObject and return it. + */ +static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa) +{ + StgDictObject *dict; + pa->keep = NULL; /* so we cannot forget it later */ + + dict = PyObject_stgdict(obj); + if (dict) { + PyCArgObject *carg; + assert(dict->paramfunc); + /* If it has an stgdict, it is a CDataObject */ + carg = dict->paramfunc((CDataObject *)obj); + if (carg == NULL) + return -1; + pa->ffi_type = carg->pffi_type; + memcpy(&pa->value, &carg->value, sizeof(pa->value)); + pa->keep = (PyObject *)carg; + return 0; + } + + ctypes_state *st = GLOBAL_STATE(); + if (PyCArg_CheckExact(st, obj)) { + PyCArgObject *carg = (PyCArgObject *)obj; + pa->ffi_type = carg->pffi_type; + pa->keep = Py_NewRef(obj); + memcpy(&pa->value, &carg->value, sizeof(pa->value)); + return 0; + } + + /* check for None, integer, string or unicode and use directly if successful */ + if (obj == Py_None) { + pa->ffi_type = &ffi_type_pointer; + pa->value.p = NULL; + return 0; + } + + if (PyLong_Check(obj)) { + pa->ffi_type = &ffi_type_sint; + pa->value.i = (long)PyLong_AsUnsignedLong(obj); + if (pa->value.i == -1 && PyErr_Occurred()) { + PyErr_Clear(); + pa->value.i = PyLong_AsLong(obj); + if (pa->value.i == -1 && PyErr_Occurred()) { + PyErr_SetString(PyExc_OverflowError, + "int too long to convert"); + return -1; + } + } + return 0; + } + + if (PyBytes_Check(obj)) { + pa->ffi_type = &ffi_type_pointer; + pa->value.p = PyBytes_AsString(obj); + pa->keep = Py_NewRef(obj); + return 0; + } + + if (PyUnicode_Check(obj)) { + pa->ffi_type = &ffi_type_pointer; + pa->value.p = PyUnicode_AsWideCharString(obj, NULL); + if (pa->value.p == NULL) + return -1; + pa->keep = PyCapsule_New(pa->value.p, CTYPES_CAPSULE_NAME_PYMEM, pymem_destructor); + if (!pa->keep) { + PyMem_Free(pa->value.p); + return -1; + } + return 0; + } + + { + PyObject *arg; + if (_PyObject_LookupAttr(obj, _Py_ID(_as_parameter_), &arg) < 0) { + return -1; + } + /* Which types should we exactly allow here? + integers are required for using Python classes + as parameters (they have to expose the '_as_parameter_' + attribute) + */ + if (arg) { + int result; + result = ConvParam(arg, index, pa); + Py_DECREF(arg); + return result; + } + PyErr_Format(PyExc_TypeError, + "Don't know how to convert parameter %d", + Py_SAFE_DOWNCAST(index, Py_ssize_t, int)); + return -1; + } +} + +#if defined(MS_WIN32) && !defined(_WIN32_WCE) +/* +Per: https://msdn.microsoft.com/en-us/library/7572ztz4.aspx +To be returned by value in RAX, user-defined types must have a length +of 1, 2, 4, 8, 16, 32, or 64 bits +*/ +int can_return_struct_as_int(size_t s) +{ + return s == 1 || s == 2 || s == 4; +} + +int can_return_struct_as_sint64(size_t s) +{ +#ifdef _M_ARM + // 8 byte structs cannot be returned in a register on ARM32 + return 0; +#else + return s == 8; +#endif +} +#endif + + +ffi_type *_ctypes_get_ffi_type(PyObject *obj) +{ + StgDictObject *dict; + if (obj == NULL) + return &ffi_type_sint; + dict = PyType_stgdict(obj); + if (dict == NULL) + return &ffi_type_sint; +#if defined(MS_WIN32) && !defined(_WIN32_WCE) + /* This little trick works correctly with MSVC. + It returns small structures in registers + */ + if (dict->ffi_type_pointer.type == FFI_TYPE_STRUCT) { + if (can_return_struct_as_int(dict->ffi_type_pointer.size)) + return &ffi_type_sint32; + else if (can_return_struct_as_sint64 (dict->ffi_type_pointer.size)) + return &ffi_type_sint64; + } +#endif + return &dict->ffi_type_pointer; +} + + +/* + * libffi uses: + * + * ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, + * unsigned int nargs, + * ffi_type *rtype, + * ffi_type **atypes); + * + * and then + * + * void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues); + */ +static int _call_function_pointer(int flags, + PPROC pProc, + void **avalues, + ffi_type **atypes, + ffi_type *restype, + void *resmem, + int argcount, + int argtypecount) +{ + PyThreadState *_save = NULL; /* For Py_BLOCK_THREADS and Py_UNBLOCK_THREADS */ + PyObject *error_object = NULL; + int *space; + ffi_cif cif; + int cc; +#if defined(MS_WIN32) && !defined(DONT_USE_SEH) + DWORD dwExceptionCode = 0; + EXCEPTION_RECORD record; +#endif + /* XXX check before here */ + if (restype == NULL) { + PyErr_SetString(PyExc_RuntimeError, + "No ffi_type for result"); + return -1; + } + + cc = FFI_DEFAULT_ABI; +#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(_WIN32_WCE) && !defined(_M_ARM) + if ((flags & FUNCFLAG_CDECL) == 0) + cc = FFI_STDCALL; +#endif + +# ifdef USING_APPLE_OS_LIBFFI +# ifdef HAVE_BUILTIN_AVAILABLE +# define HAVE_FFI_PREP_CIF_VAR_RUNTIME __builtin_available(macos 10.15, ios 13, watchos 6, tvos 13, *) +# else +# define HAVE_FFI_PREP_CIF_VAR_RUNTIME (ffi_prep_cif_var != NULL) +# endif +# elif HAVE_FFI_PREP_CIF_VAR +# define HAVE_FFI_PREP_CIF_VAR_RUNTIME true +# else +# define HAVE_FFI_PREP_CIF_VAR_RUNTIME false +# endif + + /* Even on Apple-arm64 the calling convention for variadic functions coincides + * with the standard calling convention in the case that the function called + * only with its fixed arguments. Thus, we do not need a special flag to be + * set on variadic functions. We treat a function as variadic if it is called + * with a nonzero number of variadic arguments */ + bool is_variadic = (argtypecount != 0 && argcount > argtypecount); + (void) is_variadic; + +#if defined(__APPLE__) && defined(__arm64__) + if (is_variadic) { + if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) { + } else { + PyErr_SetString(PyExc_NotImplementedError, "ffi_prep_cif_var() is missing"); + return -1; + } + } +#endif + +#if HAVE_FFI_PREP_CIF_VAR + if (is_variadic) { + if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) { + if (FFI_OK != ffi_prep_cif_var(&cif, + cc, + argtypecount, + argcount, + restype, + atypes)) { + PyErr_SetString(PyExc_RuntimeError, + "ffi_prep_cif_var failed"); + return -1; + } + } else { + if (FFI_OK != ffi_prep_cif(&cif, + cc, + argcount, + restype, + atypes)) { + PyErr_SetString(PyExc_RuntimeError, + "ffi_prep_cif failed"); + return -1; + } + } + } else +#endif + + { + if (FFI_OK != ffi_prep_cif(&cif, + cc, + argcount, + restype, + atypes)) { + PyErr_SetString(PyExc_RuntimeError, + "ffi_prep_cif failed"); + return -1; + } + } + + if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) { + error_object = _ctypes_get_errobj(&space); + if (error_object == NULL) + return -1; + } + if ((flags & FUNCFLAG_PYTHONAPI) == 0) + Py_UNBLOCK_THREADS + if (flags & FUNCFLAG_USE_ERRNO) { + int temp = space[0]; + space[0] = errno; + errno = temp; + } +#ifdef MS_WIN32 + if (flags & FUNCFLAG_USE_LASTERROR) { + int temp = space[1]; + space[1] = GetLastError(); + SetLastError(temp); + } +#ifndef DONT_USE_SEH + __try { +#endif +#endif + ffi_call(&cif, (void *)pProc, resmem, avalues); +#ifdef MS_WIN32 +#ifndef DONT_USE_SEH + } + __except (HandleException(GetExceptionInformation(), + &dwExceptionCode, &record)) { + ; + } +#endif + if (flags & FUNCFLAG_USE_LASTERROR) { + int temp = space[1]; + space[1] = GetLastError(); + SetLastError(temp); + } +#endif + if (flags & FUNCFLAG_USE_ERRNO) { + int temp = space[0]; + space[0] = errno; + errno = temp; + } + if ((flags & FUNCFLAG_PYTHONAPI) == 0) + Py_BLOCK_THREADS + Py_XDECREF(error_object); +#ifdef MS_WIN32 +#ifndef DONT_USE_SEH + if (dwExceptionCode) { + SetException(dwExceptionCode, &record); + return -1; + } +#endif +#endif + if ((flags & FUNCFLAG_PYTHONAPI) && PyErr_Occurred()) + return -1; + return 0; +} + +/* + * Convert the C value in result into a Python object, depending on restype. + * + * - If restype is NULL, return a Python integer. + * - If restype is None, return None. + * - If restype is a simple ctypes type (c_int, c_void_p), call the type's getfunc, + * pass the result to checker and return the result. + * - If restype is another ctypes type, return an instance of that. + * - Otherwise, call restype and return the result. + */ +static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker) +{ + StgDictObject *dict; + PyObject *retval, *v; + + if (restype == NULL) + return PyLong_FromLong(*(int *)result); + + if (restype == Py_None) { + Py_RETURN_NONE; + } + + dict = PyType_stgdict(restype); + if (dict == NULL) + return PyObject_CallFunction(restype, "i", *(int *)result); + + if (dict->getfunc && !_ctypes_simple_instance(restype)) { + retval = dict->getfunc(result, dict->size); + /* If restype is py_object (detected by comparing getfunc with + O_get), we have to call Py_DECREF because O_get has already + called Py_INCREF. + */ + if (dict->getfunc == _ctypes_get_fielddesc("O")->getfunc) { + Py_DECREF(retval); + } + } else + retval = PyCData_FromBaseObj(restype, NULL, 0, result); + + if (!checker || !retval) + return retval; + + v = PyObject_CallOneArg(checker, retval); + if (v == NULL) + _PyTraceback_Add("GetResult", "_ctypes/callproc.c", __LINE__-2); + Py_DECREF(retval); + return v; +} + +/* + * Raise a new exception 'exc_class', adding additional text to the original + * exception string. + */ +void _ctypes_extend_error(PyObject *exc_class, const char *fmt, ...) +{ + va_list vargs; + + va_start(vargs, fmt); + PyObject *s = PyUnicode_FromFormatV(fmt, vargs); + va_end(vargs); + if (s == NULL) { + return; + } + + assert(PyErr_Occurred()); + PyObject *exc = PyErr_GetRaisedException(); + assert(exc != NULL); + PyObject *cls_str = PyType_GetName(Py_TYPE(exc)); + if (cls_str) { + PyUnicode_AppendAndDel(&s, cls_str); + PyUnicode_AppendAndDel(&s, PyUnicode_FromString(": ")); + if (s == NULL) { + goto error; + } + } + else { + PyErr_Clear(); + } + + PyObject *msg_str = PyObject_Str(exc); + if (msg_str) { + PyUnicode_AppendAndDel(&s, msg_str); + } + else { + PyErr_Clear(); + PyUnicode_AppendAndDel(&s, PyUnicode_FromString("???")); + } + if (s == NULL) { + goto error; + } + PyErr_SetObject(exc_class, s); +error: + Py_XDECREF(exc); + Py_XDECREF(s); +} + + +#ifdef MS_WIN32 + +static PyObject * +GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk) +{ + HRESULT hr; + ISupportErrorInfo *psei = NULL; + IErrorInfo *pei = NULL; + BSTR descr=NULL, helpfile=NULL, source=NULL; + GUID guid; + DWORD helpcontext=0; + LPOLESTR progid; + PyObject *obj; + LPOLESTR text; + + /* We absolutely have to release the GIL during COM method calls, + otherwise we may get a deadlock! + */ + Py_BEGIN_ALLOW_THREADS + + hr = pIunk->lpVtbl->QueryInterface(pIunk, &IID_ISupportErrorInfo, (void **)&psei); + if (FAILED(hr)) + goto failed; + + hr = psei->lpVtbl->InterfaceSupportsErrorInfo(psei, riid); + psei->lpVtbl->Release(psei); + if (FAILED(hr)) + goto failed; + + hr = GetErrorInfo(0, &pei); + if (hr != S_OK) + goto failed; + + pei->lpVtbl->GetDescription(pei, &descr); + pei->lpVtbl->GetGUID(pei, &guid); + pei->lpVtbl->GetHelpContext(pei, &helpcontext); + pei->lpVtbl->GetHelpFile(pei, &helpfile); + pei->lpVtbl->GetSource(pei, &source); + + pei->lpVtbl->Release(pei); + + failed: + Py_END_ALLOW_THREADS + + progid = NULL; + ProgIDFromCLSID(&guid, &progid); + + text = FormatError(errcode); + obj = Py_BuildValue( + "iu(uuuiu)", + errcode, + text, + descr, source, helpfile, helpcontext, + progid); + if (obj) { + ctypes_state *st = GLOBAL_STATE(); + PyErr_SetObject((PyObject *)st->PyComError_Type, obj); + Py_DECREF(obj); + } + LocalFree(text); + + if (descr) + SysFreeString(descr); + if (helpfile) + SysFreeString(helpfile); + if (source) + SysFreeString(source); + + return NULL; +} +#endif + +#if (defined(__x86_64__) && (defined(__MINGW64__) || defined(__CYGWIN__))) || \ + defined(__aarch64__) || defined(__riscv) +#define CTYPES_PASS_BY_REF_HACK +#define POW2(x) (((x & ~(x - 1)) == x) ? x : 0) +#define IS_PASS_BY_REF(x) (x > 8 || !POW2(x)) +#endif + +/* + * Requirements, must be ensured by the caller: + * - argtuple is tuple of arguments + * - argtypes is either NULL, or a tuple of the same size as argtuple + * + * - XXX various requirements for restype, not yet collected + */ +PyObject *_ctypes_callproc(PPROC pProc, + PyObject *argtuple, +#ifdef MS_WIN32 + IUnknown *pIunk, + GUID *iid, +#endif + int flags, + PyObject *argtypes, /* misleading name: This is a tuple of + methods, not types: the .from_param + class methods of the types */ + PyObject *restype, + PyObject *checker) +{ + Py_ssize_t i, n, argcount, argtype_count; + void *resbuf; + struct argument *args, *pa; + ffi_type **atypes; + ffi_type *rtype; + void **avalues; + PyObject *retval = NULL; + + n = argcount = PyTuple_GET_SIZE(argtuple); +#ifdef MS_WIN32 + /* an optional COM object this pointer */ + if (pIunk) + ++argcount; +#endif + + if (argcount > CTYPES_MAX_ARGCOUNT) + { + PyErr_Format(PyExc_ArgError, "too many arguments (%zi), maximum is %i", + argcount, CTYPES_MAX_ARGCOUNT); + return NULL; + } + + args = alloca(sizeof(struct argument) * argcount); + memset(args, 0, sizeof(struct argument) * argcount); + argtype_count = argtypes ? PyTuple_GET_SIZE(argtypes) : 0; +#ifdef MS_WIN32 + if (pIunk) { + args[0].ffi_type = &ffi_type_pointer; + args[0].value.p = pIunk; + pa = &args[1]; + } else +#endif + pa = &args[0]; + + /* Convert the arguments */ + for (i = 0; i < n; ++i, ++pa) { + PyObject *converter; + PyObject *arg; + int err; + + arg = PyTuple_GET_ITEM(argtuple, i); /* borrowed ref */ + /* For cdecl functions, we allow more actual arguments + than the length of the argtypes tuple. + This is checked in _ctypes::PyCFuncPtr_Call + */ + if (argtypes && argtype_count > i) { + PyObject *v; + converter = PyTuple_GET_ITEM(argtypes, i); + v = PyObject_CallOneArg(converter, arg); + if (v == NULL) { + _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1); + goto cleanup; + } + + err = ConvParam(v, i+1, pa); + Py_DECREF(v); + if (-1 == err) { + _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1); + goto cleanup; + } + } else { + err = ConvParam(arg, i+1, pa); + if (-1 == err) { + _ctypes_extend_error(PyExc_ArgError, "argument %zd: ", i+1); + goto cleanup; /* leaking ? */ + } + } + } + + if (restype == Py_None) { + rtype = &ffi_type_void; + } else { + rtype = _ctypes_get_ffi_type(restype); + } + + resbuf = alloca(max(rtype->size, sizeof(ffi_arg))); + +#ifdef _Py_MEMORY_SANITIZER + /* ffi_call actually initializes resbuf, but from asm, which + * MemorySanitizer can't detect. Avoid false positives from MSan. */ + if (resbuf != NULL) { + __msan_unpoison(resbuf, max(rtype->size, sizeof(ffi_arg))); + } +#endif + avalues = (void **)alloca(sizeof(void *) * argcount); + atypes = (ffi_type **)alloca(sizeof(ffi_type *) * argcount); + if (!resbuf || !avalues || !atypes) { + PyErr_NoMemory(); + goto cleanup; + } + for (i = 0; i < argcount; ++i) { + atypes[i] = args[i].ffi_type; +#ifdef CTYPES_PASS_BY_REF_HACK + size_t size = atypes[i]->size; + if (IS_PASS_BY_REF(size)) { + void *tmp = alloca(size); + if (atypes[i]->type == FFI_TYPE_STRUCT) + memcpy(tmp, args[i].value.p, size); + else + memcpy(tmp, (void*)&args[i].value, size); + + avalues[i] = tmp; + } + else +#endif + if (atypes[i]->type == FFI_TYPE_STRUCT) + avalues[i] = (void *)args[i].value.p; + else + avalues[i] = (void *)&args[i].value; + } + + if (-1 == _call_function_pointer(flags, pProc, avalues, atypes, + rtype, resbuf, + Py_SAFE_DOWNCAST(argcount, Py_ssize_t, int), + Py_SAFE_DOWNCAST(argtype_count, Py_ssize_t, int))) + goto cleanup; + +#ifdef WORDS_BIGENDIAN + /* libffi returns the result in a buffer with sizeof(ffi_arg). This + causes problems on big endian machines, since the result buffer + address cannot simply be used as result pointer, instead we must + adjust the pointer value: + */ + /* + XXX I should find out and clarify why this is needed at all, + especially why adjusting for ffi_type_float must be avoided on + 64-bit platforms. + */ + if (rtype->type != FFI_TYPE_FLOAT + && rtype->type != FFI_TYPE_STRUCT + && rtype->size < sizeof(ffi_arg)) + { + resbuf = (char *)resbuf + sizeof(ffi_arg) - rtype->size; + } +#endif + +#ifdef MS_WIN32 + if (iid && pIunk) { + if (*(int *)resbuf & 0x80000000) + retval = GetComError(*(HRESULT *)resbuf, iid, pIunk); + else + retval = PyLong_FromLong(*(int *)resbuf); + } else if (flags & FUNCFLAG_HRESULT) { + if (*(int *)resbuf & 0x80000000) + retval = PyErr_SetFromWindowsErr(*(int *)resbuf); + else + retval = PyLong_FromLong(*(int *)resbuf); + } else +#endif + retval = GetResult(restype, resbuf, checker); + cleanup: + for (i = 0; i < argcount; ++i) + Py_XDECREF(args[i].keep); + return retval; +} + +static int +_parse_voidp(PyObject *obj, void **address) +{ + *address = PyLong_AsVoidPtr(obj); + if (*address == NULL) + return 0; + return 1; +} + +#ifdef MS_WIN32 + +PyDoc_STRVAR(format_error_doc, +"FormatError([integer]) -> string\n\ +\n\ +Convert a win32 error code into a string. If the error code is not\n\ +given, the return value of a call to GetLastError() is used.\n"); +static PyObject *format_error(PyObject *self, PyObject *args) +{ + PyObject *result; + wchar_t *lpMsgBuf; + DWORD code = 0; + if (!PyArg_ParseTuple(args, "|i:FormatError", &code)) + return NULL; + if (code == 0) + code = GetLastError(); + lpMsgBuf = FormatError(code); + if (lpMsgBuf) { + result = PyUnicode_FromWideChar(lpMsgBuf, wcslen(lpMsgBuf)); + LocalFree(lpMsgBuf); + } else { + result = PyUnicode_FromString(""); + } + return result; +} + +PyDoc_STRVAR(load_library_doc, +"LoadLibrary(name, load_flags) -> handle\n\ +\n\ +Load an executable (usually a DLL), and return a handle to it.\n\ +The handle may be used to locate exported functions in this\n\ +module. load_flags are as defined for LoadLibraryEx in the\n\ +Windows API.\n"); +static PyObject *load_library(PyObject *self, PyObject *args) +{ + PyObject *nameobj; + int load_flags = 0; + HMODULE hMod; + DWORD err; + + if (!PyArg_ParseTuple(args, "U|i:LoadLibrary", &nameobj, &load_flags)) + return NULL; + + if (PySys_Audit("ctypes.dlopen", "O", nameobj) < 0) { + return NULL; + } + + WCHAR *name = PyUnicode_AsWideCharString(nameobj, NULL); + if (!name) + return NULL; + + Py_BEGIN_ALLOW_THREADS + /* bpo-36085: Limit DLL search directories to avoid pre-loading + * attacks and enable use of the AddDllDirectory function. + */ + hMod = LoadLibraryExW(name, NULL, (DWORD)load_flags); + err = hMod ? 0 : GetLastError(); + Py_END_ALLOW_THREADS + + PyMem_Free(name); + if (err == ERROR_MOD_NOT_FOUND) { + PyErr_Format(PyExc_FileNotFoundError, + ("Could not find module '%.500S' (or one of its " + "dependencies). Try using the full path with " + "constructor syntax."), + nameobj); + return NULL; + } else if (err) { + return PyErr_SetFromWindowsErr(err); + } +#ifdef _WIN64 + return PyLong_FromVoidPtr(hMod); +#else + return Py_BuildValue("i", hMod); +#endif +} + +PyDoc_STRVAR(free_library_doc, +"FreeLibrary(handle) -> void\n\ +\n\ +Free the handle of an executable previously loaded by LoadLibrary.\n"); +static PyObject *free_library(PyObject *self, PyObject *args) +{ + void *hMod; + BOOL result; + DWORD err; + if (!PyArg_ParseTuple(args, "O&:FreeLibrary", &_parse_voidp, &hMod)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + result = FreeLibrary((HMODULE)hMod); + err = result ? 0 : GetLastError(); + Py_END_ALLOW_THREADS + + if (!result) { + return PyErr_SetFromWindowsErr(err); + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(copy_com_pointer_doc, +"CopyComPointer(src, dst) -> HRESULT value\n"); + +static PyObject * +copy_com_pointer(PyObject *self, PyObject *args) +{ + PyObject *p1, *p2, *r = NULL; + struct argument a, b; + IUnknown *src, **pdst; + if (!PyArg_ParseTuple(args, "OO:CopyComPointer", &p1, &p2)) + return NULL; + a.keep = b.keep = NULL; + + if (-1 == ConvParam(p1, 0, &a) || -1 == ConvParam(p2, 1, &b)) + goto done; + src = (IUnknown *)a.value.p; + pdst = (IUnknown **)b.value.p; + + if (pdst == NULL) + r = PyLong_FromLong(E_POINTER); + else { + if (src) + src->lpVtbl->AddRef(src); + *pdst = src; + r = PyLong_FromLong(S_OK); + } + done: + Py_XDECREF(a.keep); + Py_XDECREF(b.keep); + return r; +} +#else +#ifdef __APPLE__ +#ifdef HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH +# ifdef HAVE_BUILTIN_AVAILABLE +# define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME \ + __builtin_available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *) +# else +# define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME \ + (_dyld_shared_cache_contains_path != NULL) +# endif +#else +// Support the deprecated case of compiling on an older macOS version +static void *libsystem_b_handle; +static bool (*_dyld_shared_cache_contains_path)(const char *path); + +__attribute__((constructor)) void load_dyld_shared_cache_contains_path(void) { + libsystem_b_handle = dlopen("/usr/lib/libSystem.B.dylib", RTLD_LAZY); + if (libsystem_b_handle != NULL) { + _dyld_shared_cache_contains_path = dlsym(libsystem_b_handle, "_dyld_shared_cache_contains_path"); + } +} + +__attribute__((destructor)) void unload_dyld_shared_cache_contains_path(void) { + if (libsystem_b_handle != NULL) { + dlclose(libsystem_b_handle); + } +} +#define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME \ + _dyld_shared_cache_contains_path != NULL +#endif + +static PyObject *py_dyld_shared_cache_contains_path(PyObject *self, PyObject *args) +{ + PyObject *name, *name2; + char *name_str; + + if (HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME) { + int r; + + if (!PyArg_ParseTuple(args, "O", &name)) + return NULL; + + if (name == Py_None) + Py_RETURN_FALSE; + + if (PyUnicode_FSConverter(name, &name2) == 0) + return NULL; + name_str = PyBytes_AS_STRING(name2); + + r = _dyld_shared_cache_contains_path(name_str); + Py_DECREF(name2); + + if (r) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + + } else { + PyErr_SetString(PyExc_NotImplementedError, "_dyld_shared_cache_contains_path symbol is missing"); + return NULL; + } + + } +#endif + +static PyObject *py_dl_open(PyObject *self, PyObject *args) +{ + PyObject *name, *name2; + const char *name_str; + void * handle; +#if HAVE_DECL_RTLD_LOCAL + int mode = RTLD_NOW | RTLD_LOCAL; +#else + /* cygwin doesn't define RTLD_LOCAL */ + int mode = RTLD_NOW; +#endif + if (!PyArg_ParseTuple(args, "O|i:dlopen", &name, &mode)) + return NULL; + mode |= RTLD_NOW; + if (name != Py_None) { + if (PyUnicode_FSConverter(name, &name2) == 0) + return NULL; + name_str = PyBytes_AS_STRING(name2); + } else { + name_str = NULL; + name2 = NULL; + } + if (PySys_Audit("ctypes.dlopen", "O", name) < 0) { + return NULL; + } + handle = dlopen(name_str, mode); + Py_XDECREF(name2); + if (!handle) { + const char *errmsg = dlerror(); + if (!errmsg) + errmsg = "dlopen() error"; + PyErr_SetString(PyExc_OSError, + errmsg); + return NULL; + } + return PyLong_FromVoidPtr(handle); +} + +static PyObject *py_dl_close(PyObject *self, PyObject *args) +{ + void *handle; + + if (!PyArg_ParseTuple(args, "O&:dlclose", &_parse_voidp, &handle)) + return NULL; + if (dlclose(handle)) { + PyErr_SetString(PyExc_OSError, + dlerror()); + return NULL; + } + Py_RETURN_NONE; +} + +static PyObject *py_dl_sym(PyObject *self, PyObject *args) +{ + char *name; + void *handle; + void *ptr; + + if (!PyArg_ParseTuple(args, "O&s:dlsym", + &_parse_voidp, &handle, &name)) + return NULL; + if (PySys_Audit("ctypes.dlsym/handle", "O", args) < 0) { + return NULL; + } + ptr = dlsym((void*)handle, name); + if (!ptr) { + PyErr_SetString(PyExc_OSError, + dlerror()); + return NULL; + } + return PyLong_FromVoidPtr(ptr); +} +#endif + +/* + * Only for debugging so far: So that we can call CFunction instances + * + * XXX Needs to accept more arguments: flags, argtypes, restype + */ +static PyObject * +call_function(PyObject *self, PyObject *args) +{ + void *func; + PyObject *arguments; + PyObject *result; + + if (!PyArg_ParseTuple(args, + "O&O!", + &_parse_voidp, &func, + &PyTuple_Type, &arguments)) + return NULL; + if (PySys_Audit("ctypes.call_function", "nO", + (Py_ssize_t)func, arguments) < 0) { + return NULL; + } + + result = _ctypes_callproc((PPROC)func, + arguments, +#ifdef MS_WIN32 + NULL, + NULL, +#endif + 0, /* flags */ + NULL, /* self->argtypes */ + NULL, /* self->restype */ + NULL); /* checker */ + return result; +} + +/* + * Only for debugging so far: So that we can call CFunction instances + * + * XXX Needs to accept more arguments: flags, argtypes, restype + */ +static PyObject * +call_cdeclfunction(PyObject *self, PyObject *args) +{ + void *func; + PyObject *arguments; + PyObject *result; + + if (!PyArg_ParseTuple(args, + "O&O!", + &_parse_voidp, &func, + &PyTuple_Type, &arguments)) + return NULL; + if (PySys_Audit("ctypes.call_function", "nO", + (Py_ssize_t)func, arguments) < 0) { + return NULL; + } + + result = _ctypes_callproc((PPROC)func, + arguments, +#ifdef MS_WIN32 + NULL, + NULL, +#endif + FUNCFLAG_CDECL, /* flags */ + NULL, /* self->argtypes */ + NULL, /* self->restype */ + NULL); /* checker */ + return result; +} + +/***************************************************************** + * functions + */ +PyDoc_STRVAR(sizeof_doc, +"sizeof(C type) -> integer\n" +"sizeof(C instance) -> integer\n" +"Return the size in bytes of a C instance"); + +static PyObject * +sizeof_func(PyObject *self, PyObject *obj) +{ + StgDictObject *dict; + + dict = PyType_stgdict(obj); + if (dict) + return PyLong_FromSsize_t(dict->size); + + if (CDataObject_Check(obj)) + return PyLong_FromSsize_t(((CDataObject *)obj)->b_size); + PyErr_SetString(PyExc_TypeError, + "this type has no size"); + return NULL; +} + +PyDoc_STRVAR(alignment_doc, +"alignment(C type) -> integer\n" +"alignment(C instance) -> integer\n" +"Return the alignment requirements of a C instance"); + +static PyObject * +align_func(PyObject *self, PyObject *obj) +{ + StgDictObject *dict; + + dict = PyType_stgdict(obj); + if (dict) + return PyLong_FromSsize_t(dict->align); + + dict = PyObject_stgdict(obj); + if (dict) + return PyLong_FromSsize_t(dict->align); + + PyErr_SetString(PyExc_TypeError, + "no alignment info"); + return NULL; +} + +PyDoc_STRVAR(byref_doc, +"byref(C instance[, offset=0]) -> byref-object\n" +"Return a pointer lookalike to a C instance, only usable\n" +"as function argument"); + +/* + * We must return something which can be converted to a parameter, + * but still has a reference to self. + */ +static PyObject * +byref(PyObject *self, PyObject *args) +{ + PyCArgObject *parg; + PyObject *obj; + PyObject *pyoffset = NULL; + Py_ssize_t offset = 0; + + if (!PyArg_UnpackTuple(args, "byref", 1, 2, + &obj, &pyoffset)) + return NULL; + if (pyoffset) { + offset = PyNumber_AsSsize_t(pyoffset, NULL); + if (offset == -1 && PyErr_Occurred()) + return NULL; + } + if (!CDataObject_Check(obj)) { + PyErr_Format(PyExc_TypeError, + "byref() argument must be a ctypes instance, not '%s'", + Py_TYPE(obj)->tp_name); + return NULL; + } + + parg = PyCArgObject_new(); + if (parg == NULL) + return NULL; + + parg->tag = 'P'; + parg->pffi_type = &ffi_type_pointer; + parg->obj = Py_NewRef(obj); + parg->value.p = (char *)((CDataObject *)obj)->b_ptr + offset; + return (PyObject *)parg; +} + +PyDoc_STRVAR(addressof_doc, +"addressof(C instance) -> integer\n" +"Return the address of the C instance internal buffer"); + +static PyObject * +addressof(PyObject *self, PyObject *obj) +{ + if (!CDataObject_Check(obj)) { + PyErr_SetString(PyExc_TypeError, + "invalid type"); + return NULL; + } + if (PySys_Audit("ctypes.addressof", "(O)", obj) < 0) { + return NULL; + } + return PyLong_FromVoidPtr(((CDataObject *)obj)->b_ptr); +} + +static int +converter(PyObject *obj, void **address) +{ + *address = PyLong_AsVoidPtr(obj); + return *address != NULL; +} + +static PyObject * +My_PyObj_FromPtr(PyObject *self, PyObject *args) +{ + PyObject *ob; + if (!PyArg_ParseTuple(args, "O&:PyObj_FromPtr", converter, &ob)) { + return NULL; + } + if (PySys_Audit("ctypes.PyObj_FromPtr", "(O)", ob) < 0) { + return NULL; + } + return Py_NewRef(ob); +} + +static PyObject * +My_Py_INCREF(PyObject *self, PyObject *arg) +{ + Py_INCREF(arg); /* that's what this function is for */ + Py_INCREF(arg); /* that for returning it */ + return arg; +} + +static PyObject * +My_Py_DECREF(PyObject *self, PyObject *arg) +{ + Py_DECREF(arg); /* that's what this function is for */ + Py_INCREF(arg); /* that's for returning it */ + return arg; +} + +static PyObject * +resize(PyObject *self, PyObject *args) +{ + CDataObject *obj; + StgDictObject *dict; + Py_ssize_t size; + + if (!PyArg_ParseTuple(args, + "On:resize", + &obj, &size)) + return NULL; + + dict = PyObject_stgdict((PyObject *)obj); + if (dict == NULL) { + PyErr_SetString(PyExc_TypeError, + "expected ctypes instance"); + return NULL; + } + if (size < dict->size) { + PyErr_Format(PyExc_ValueError, + "minimum size is %zd", + dict->size); + return NULL; + } + if (obj->b_needsfree == 0) { + PyErr_Format(PyExc_ValueError, + "Memory cannot be resized because this object doesn't own it"); + return NULL; + } + if ((size_t)size <= sizeof(obj->b_value)) { + /* internal default buffer is large enough */ + obj->b_size = size; + goto done; + } + if (!_CDataObject_HasExternalBuffer(obj)) { + /* We are currently using the objects default buffer, but it + isn't large enough any more. */ + void *ptr = PyMem_Calloc(1, size); + if (ptr == NULL) + return PyErr_NoMemory(); + memmove(ptr, obj->b_ptr, obj->b_size); + obj->b_ptr = ptr; + obj->b_size = size; + } else { + void * ptr = PyMem_Realloc(obj->b_ptr, size); + if (ptr == NULL) + return PyErr_NoMemory(); + obj->b_ptr = ptr; + obj->b_size = size; + } + done: + Py_RETURN_NONE; +} + +static PyObject * +unpickle(PyObject *self, PyObject *args) +{ + PyObject *typ, *state, *meth, *obj, *result; + + if (!PyArg_ParseTuple(args, "OO!", &typ, &PyTuple_Type, &state)) + return NULL; + obj = PyObject_CallMethodOneArg(typ, _Py_ID(__new__), typ); + if (obj == NULL) + return NULL; + + meth = PyObject_GetAttr(obj, _Py_ID(__setstate__)); + if (meth == NULL) { + goto error; + } + + result = PyObject_Call(meth, state, NULL); + Py_DECREF(meth); + if (result == NULL) { + goto error; + } + Py_DECREF(result); + + return obj; + +error: + Py_DECREF(obj); + return NULL; +} + +static PyObject * +POINTER(PyObject *self, PyObject *cls) +{ + PyObject *result; + PyTypeObject *typ; + PyObject *key; + + result = PyDict_GetItemWithError(_ctypes_ptrtype_cache, cls); + if (result) { + return Py_NewRef(result); + } + else if (PyErr_Occurred()) { + return NULL; + } + if (PyUnicode_CheckExact(cls)) { + PyObject *name = PyUnicode_FromFormat("LP_%U", cls); + result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type), + "N(O){}", + name, + &PyCPointer_Type); + if (result == NULL) + return result; + key = PyLong_FromVoidPtr(result); + if (key == NULL) { + Py_DECREF(result); + return NULL; + } + } else if (PyType_Check(cls)) { + typ = (PyTypeObject *)cls; + PyObject *name = PyUnicode_FromFormat("LP_%s", typ->tp_name); + result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type), + "N(O){sO}", + name, + &PyCPointer_Type, + "_type_", cls); + if (result == NULL) + return result; + key = Py_NewRef(cls); + } else { + PyErr_SetString(PyExc_TypeError, "must be a ctypes type"); + return NULL; + } + if (-1 == PyDict_SetItem(_ctypes_ptrtype_cache, key, result)) { + Py_DECREF(result); + Py_DECREF(key); + return NULL; + } + Py_DECREF(key); + return result; +} + +static PyObject * +pointer(PyObject *self, PyObject *arg) +{ + PyObject *result; + PyObject *typ; + + typ = PyDict_GetItemWithError(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg)); + if (typ) { + return PyObject_CallOneArg(typ, arg); + } + else if (PyErr_Occurred()) { + return NULL; + } + typ = POINTER(NULL, (PyObject *)Py_TYPE(arg)); + if (typ == NULL) + return NULL; + result = PyObject_CallOneArg(typ, arg); + Py_DECREF(typ); + return result; +} + +static PyObject * +buffer_info(PyObject *self, PyObject *arg) +{ + StgDictObject *dict = PyType_stgdict(arg); + PyObject *shape; + Py_ssize_t i; + + if (dict == NULL) + dict = PyObject_stgdict(arg); + if (dict == NULL) { + PyErr_SetString(PyExc_TypeError, + "not a ctypes type or object"); + return NULL; + } + shape = PyTuple_New(dict->ndim); + if (shape == NULL) + return NULL; + for (i = 0; i < (int)dict->ndim; ++i) + PyTuple_SET_ITEM(shape, i, PyLong_FromSsize_t(dict->shape[i])); + + if (PyErr_Occurred()) { + Py_DECREF(shape); + return NULL; + } + return Py_BuildValue("siN", dict->format, dict->ndim, shape); +} + + + +PyMethodDef _ctypes_module_methods[] = { + {"get_errno", get_errno, METH_NOARGS}, + {"set_errno", set_errno, METH_VARARGS}, + {"POINTER", POINTER, METH_O }, + {"pointer", pointer, METH_O }, + {"_unpickle", unpickle, METH_VARARGS }, + {"buffer_info", buffer_info, METH_O, "Return buffer interface information"}, + {"resize", resize, METH_VARARGS, "Resize the memory buffer of a ctypes instance"}, +#ifdef MS_WIN32 + {"get_last_error", get_last_error, METH_NOARGS}, + {"set_last_error", set_last_error, METH_VARARGS}, + {"CopyComPointer", copy_com_pointer, METH_VARARGS, copy_com_pointer_doc}, + {"FormatError", format_error, METH_VARARGS, format_error_doc}, + {"LoadLibrary", load_library, METH_VARARGS, load_library_doc}, + {"FreeLibrary", free_library, METH_VARARGS, free_library_doc}, + {"_check_HRESULT", check_hresult, METH_VARARGS}, +#else + {"dlopen", py_dl_open, METH_VARARGS, + "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library"}, + {"dlclose", py_dl_close, METH_VARARGS, "dlclose a library"}, + {"dlsym", py_dl_sym, METH_VARARGS, "find symbol in shared library"}, +#endif +#ifdef __APPLE__ + {"_dyld_shared_cache_contains_path", py_dyld_shared_cache_contains_path, METH_VARARGS, "check if path is in the shared cache"}, +#endif + {"alignment", align_func, METH_O, alignment_doc}, + {"sizeof", sizeof_func, METH_O, sizeof_doc}, + {"byref", byref, METH_VARARGS, byref_doc}, + {"addressof", addressof, METH_O, addressof_doc}, + {"call_function", call_function, METH_VARARGS }, + {"call_cdeclfunction", call_cdeclfunction, METH_VARARGS }, + {"PyObj_FromPtr", My_PyObj_FromPtr, METH_VARARGS }, + {"Py_INCREF", My_Py_INCREF, METH_O }, + {"Py_DECREF", My_Py_DECREF, METH_O }, + {NULL, NULL} /* Sentinel */ +}; + +/* + Local Variables: + compile-command: "cd .. && python setup.py -q build -g && python setup.py -q build install --home ~" + End: +*/ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/cfield.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/cfield.c new file mode 100644 index 0000000000..e1fc1674eb --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/cfield.c @@ -0,0 +1,1590 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif + +#include "Python.h" +// windows.h must be included before pycore internal headers +#ifdef MS_WIN32 +# include +#endif + +#include "pycore_bitutils.h" // _Py_bswap32() +#include "pycore_call.h" // _PyObject_CallNoArgs() + +#include +#include "ctypes.h" + + +#define CTYPES_CFIELD_CAPSULE_NAME_PYMEM "_ctypes/cfield.c pymem" + +static void pymem_destructor(PyObject *ptr) +{ + void *p = PyCapsule_GetPointer(ptr, CTYPES_CFIELD_CAPSULE_NAME_PYMEM); + if (p) { + PyMem_Free(p); + } +} + + +/******************************************************************/ +/* + PyCField_Type +*/ + +/* + * Expects the size, index and offset for the current field in *psize and + * *poffset, stores the total size so far in *psize, the offset for the next + * field in *poffset, the alignment requirements for the current field in + * *palign, and returns a field descriptor for this field. + */ +/* + * bitfields extension: + * bitsize != 0: this is a bit field. + * pbitofs points to the current bit offset, this will be updated. + * prev_desc points to the type of the previous bitfield, if any. + */ +PyObject * +PyCField_FromDesc(PyObject *desc, Py_ssize_t index, + Py_ssize_t *pfield_size, int bitsize, int *pbitofs, + Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign, + int pack, int big_endian) +{ + CFieldObject *self; + PyObject *proto; + Py_ssize_t size, align; + SETFUNC setfunc = NULL; + GETFUNC getfunc = NULL; + StgDictObject *dict; + int fieldtype; +#define NO_BITFIELD 0 +#define NEW_BITFIELD 1 +#define CONT_BITFIELD 2 +#define EXPAND_BITFIELD 3 + + ctypes_state *st = GLOBAL_STATE(); + PyTypeObject *tp = st->PyCField_Type; + self = (CFieldObject *)tp->tp_alloc(tp, 0); + if (self == NULL) + return NULL; + dict = PyType_stgdict(desc); + if (!dict) { + PyErr_SetString(PyExc_TypeError, + "has no _stginfo_"); + Py_DECREF(self); + return NULL; + } + if (bitsize /* this is a bitfield request */ + && *pfield_size /* we have a bitfield open */ +#ifdef MS_WIN32 + /* MSVC, GCC with -mms-bitfields */ + && dict->size * 8 == *pfield_size +#else + /* GCC */ + && dict->size * 8 <= *pfield_size +#endif + && (*pbitofs + bitsize) <= *pfield_size) { + /* continue bit field */ + fieldtype = CONT_BITFIELD; +#ifndef MS_WIN32 + } else if (bitsize /* this is a bitfield request */ + && *pfield_size /* we have a bitfield open */ + && dict->size * 8 >= *pfield_size + && (*pbitofs + bitsize) <= dict->size * 8) { + /* expand bit field */ + fieldtype = EXPAND_BITFIELD; +#endif + } else if (bitsize) { + /* start new bitfield */ + fieldtype = NEW_BITFIELD; + *pbitofs = 0; + *pfield_size = dict->size * 8; + } else { + /* not a bit field */ + fieldtype = NO_BITFIELD; + *pbitofs = 0; + *pfield_size = 0; + } + + size = dict->size; + proto = desc; + + /* Field descriptors for 'c_char * n' are be scpecial cased to + return a Python string instead of an Array object instance... + */ + if (PyCArrayTypeObject_Check(proto)) { + StgDictObject *adict = PyType_stgdict(proto); + StgDictObject *idict; + if (adict && adict->proto) { + idict = PyType_stgdict(adict->proto); + if (!idict) { + PyErr_SetString(PyExc_TypeError, + "has no _stginfo_"); + Py_DECREF(self); + return NULL; + } + if (idict->getfunc == _ctypes_get_fielddesc("c")->getfunc) { + struct fielddesc *fd = _ctypes_get_fielddesc("s"); + getfunc = fd->getfunc; + setfunc = fd->setfunc; + } + if (idict->getfunc == _ctypes_get_fielddesc("u")->getfunc) { + struct fielddesc *fd = _ctypes_get_fielddesc("U"); + getfunc = fd->getfunc; + setfunc = fd->setfunc; + } + } + } + + self->setfunc = setfunc; + self->getfunc = getfunc; + self->index = index; + + self->proto = Py_NewRef(proto); + + switch (fieldtype) { + case NEW_BITFIELD: + if (big_endian) + self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize; + else + self->size = (bitsize << 16) + *pbitofs; + *pbitofs = bitsize; + /* fall through */ + case NO_BITFIELD: + if (pack) + align = min(pack, dict->align); + else + align = dict->align; + if (align && *poffset % align) { + Py_ssize_t delta = align - (*poffset % align); + *psize += delta; + *poffset += delta; + } + + if (bitsize == 0) + self->size = size; + *psize += size; + + self->offset = *poffset; + *poffset += size; + + *palign = align; + break; + + case EXPAND_BITFIELD: + *poffset += dict->size - *pfield_size/8; + *psize += dict->size - *pfield_size/8; + + *pfield_size = dict->size * 8; + + if (big_endian) + self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize; + else + self->size = (bitsize << 16) + *pbitofs; + + self->offset = *poffset - size; /* poffset is already updated for the NEXT field */ + *pbitofs += bitsize; + break; + + case CONT_BITFIELD: + if (big_endian) + self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize; + else + self->size = (bitsize << 16) + *pbitofs; + + self->offset = *poffset - size; /* poffset is already updated for the NEXT field */ + *pbitofs += bitsize; + break; + } + + return (PyObject *)self; +} + +static int +PyCField_set(CFieldObject *self, PyObject *inst, PyObject *value) +{ + CDataObject *dst; + char *ptr; + if (!CDataObject_Check(inst)) { + PyErr_SetString(PyExc_TypeError, + "not a ctype instance"); + return -1; + } + dst = (CDataObject *)inst; + ptr = dst->b_ptr + self->offset; + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, + "can't delete attribute"); + return -1; + } + return PyCData_set(inst, self->proto, self->setfunc, value, + self->index, self->size, ptr); +} + +static PyObject * +PyCField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type) +{ + CDataObject *src; + if (inst == NULL) { + return Py_NewRef(self); + } + if (!CDataObject_Check(inst)) { + PyErr_SetString(PyExc_TypeError, + "not a ctype instance"); + return NULL; + } + src = (CDataObject *)inst; + return PyCData_get(self->proto, self->getfunc, inst, + self->index, self->size, src->b_ptr + self->offset); +} + +static PyObject * +PyCField_get_offset(PyObject *self, void *data) +{ + return PyLong_FromSsize_t(((CFieldObject *)self)->offset); +} + +static PyObject * +PyCField_get_size(PyObject *self, void *data) +{ + return PyLong_FromSsize_t(((CFieldObject *)self)->size); +} + +static PyGetSetDef PyCField_getset[] = { + { "offset", PyCField_get_offset, NULL, "offset in bytes of this field" }, + { "size", PyCField_get_size, NULL, "size in bytes of this field" }, + { NULL, NULL, NULL, NULL }, +}; + +static int +PyCField_traverse(CFieldObject *self, visitproc visit, void *arg) +{ + Py_VISIT(Py_TYPE(self)); + Py_VISIT(self->proto); + return 0; +} + +static int +PyCField_clear(CFieldObject *self) +{ + Py_CLEAR(self->proto); + return 0; +} + +static void +PyCField_dealloc(PyObject *self) +{ + PyTypeObject *tp = Py_TYPE(self); + PyObject_GC_UnTrack(self); + (void)PyCField_clear((CFieldObject *)self); + Py_TYPE(self)->tp_free((PyObject *)self); + Py_DECREF(tp); +} + +static PyObject * +PyCField_repr(CFieldObject *self) +{ + PyObject *result; + Py_ssize_t bits = self->size >> 16; + Py_ssize_t size = self->size & 0xFFFF; + const char *name; + + name = ((PyTypeObject *)self->proto)->tp_name; + + if (bits) + result = PyUnicode_FromFormat( + "", + name, self->offset, size, bits); + else + result = PyUnicode_FromFormat( + "", + name, self->offset, size); + return result; +} + +static PyType_Slot cfield_slots[] = { + {Py_tp_dealloc, PyCField_dealloc}, + {Py_tp_repr, PyCField_repr}, + {Py_tp_doc, (void *)PyDoc_STR("Structure/Union member")}, + {Py_tp_traverse, PyCField_traverse}, + {Py_tp_clear, PyCField_clear}, + {Py_tp_getset, PyCField_getset}, + {Py_tp_descr_get, PyCField_get}, + {Py_tp_descr_set, PyCField_set}, + {0, NULL}, +}; + +PyType_Spec cfield_spec = { + .name = "_ctypes.CField", + .basicsize = sizeof(CFieldObject), + .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), + .slots = cfield_slots, +}; + + +/******************************************************************/ +/* + Accessor functions +*/ + +/* Derived from Modules/structmodule.c: + Helper routine to get a Python integer and raise the appropriate error + if it isn't one */ + +static int +get_long(PyObject *v, long *p) +{ + long x = PyLong_AsUnsignedLongMask(v); + if (x == -1 && PyErr_Occurred()) + return -1; + *p = x; + return 0; +} + +/* Same, but handling unsigned long */ + +static int +get_ulong(PyObject *v, unsigned long *p) +{ + unsigned long x = PyLong_AsUnsignedLongMask(v); + if (x == (unsigned long)-1 && PyErr_Occurred()) + return -1; + *p = x; + return 0; +} + +/* Same, but handling native long long. */ + +static int +get_longlong(PyObject *v, long long *p) +{ + long long x = PyLong_AsUnsignedLongLongMask(v); + if (x == -1 && PyErr_Occurred()) + return -1; + *p = x; + return 0; +} + +/* Same, but handling native unsigned long long. */ + +static int +get_ulonglong(PyObject *v, unsigned long long *p) +{ + unsigned long long x = PyLong_AsUnsignedLongLongMask(v); + if (x == (unsigned long long)-1 && PyErr_Occurred()) + return -1; + *p = x; + return 0; +} + +/***************************************************************** + * Integer fields, with bitfield support + */ + +/* how to decode the size field, for integer get/set functions */ +#define LOW_BIT(x) ((x) & 0xFFFF) +#define NUM_BITS(x) ((x) >> 16) + +/* Doesn't work if NUM_BITS(size) == 0, but it never happens in SET() call. */ +#define BIT_MASK(type, size) (((((type)1 << (NUM_BITS(size) - 1)) - 1) << 1) + 1) + +/* This macro CHANGES the first parameter IN PLACE. For proper sign handling, + we must first shift left, then right. +*/ +#define GET_BITFIELD(v, size) \ + if (NUM_BITS(size)) { \ + v <<= (sizeof(v)*8 - LOW_BIT(size) - NUM_BITS(size)); \ + v >>= (sizeof(v)*8 - NUM_BITS(size)); \ + } + +/* This macro RETURNS the first parameter with the bit field CHANGED. */ +#define SET(type, x, v, size) \ + (NUM_BITS(size) ? \ + ( ( (type)x & ~(BIT_MASK(type, size) << LOW_BIT(size)) ) | ( ((type)v & BIT_MASK(type, size)) << LOW_BIT(size) ) ) \ + : (type)v) + +#if SIZEOF_SHORT == 2 +# define SWAP_SHORT _Py_bswap16 +#else +# error "unsupported short size" +#endif + +#if SIZEOF_INT == 4 +# define SWAP_INT _Py_bswap32 +#else +# error "unsupported int size" +#endif + +#if SIZEOF_LONG == 4 +# define SWAP_LONG _Py_bswap32 +#elif SIZEOF_LONG == 8 +# define SWAP_LONG _Py_bswap64 +#else +# error "unsupported long size" +#endif + +#if SIZEOF_LONG_LONG == 8 +# define SWAP_LONG_LONG _Py_bswap64 +#else +# error "unsupported long long size" +#endif + +/***************************************************************** + * The setter methods return an object which must be kept alive, to keep the + * data valid which has been stored in the memory block. The ctypes object + * instance inserts this object into its 'b_objects' list. + * + * For simple Python types like integers or characters, there is nothing that + * has to been kept alive, so Py_None is returned in these cases. But this + * makes inspecting the 'b_objects' list, which is accessible from Python for + * debugging, less useful. + * + * So, defining the _CTYPES_DEBUG_KEEP symbol returns the original value + * instead of Py_None. + */ + +#ifdef _CTYPES_DEBUG_KEEP +#define _RET(x) Py_INCREF(x); return x +#else +#define _RET(X) Py_RETURN_NONE +#endif + +/***************************************************************** + * integer accessor methods, supporting bit fields + */ + +static PyObject * +b_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + if (get_long(value, &val) < 0) + return NULL; + *(signed char *)ptr = SET(signed char, *(signed char *)ptr, val, size); + _RET(value); +} + + +static PyObject * +b_get(void *ptr, Py_ssize_t size) +{ + signed char val = *(signed char *)ptr; + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +B_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + if (get_ulong(value, &val) < 0) + return NULL; + *(unsigned char *)ptr = SET(unsigned char, *(unsigned char*)ptr, val, size); + _RET(value); +} + + +static PyObject * +B_get(void *ptr, Py_ssize_t size) +{ + unsigned char val = *(unsigned char *)ptr; + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +h_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + short x; + if (get_long(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(short, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + + +static PyObject * +h_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + short field; + if (get_long(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_SHORT(field); + field = SET(short, field, val, size); + field = SWAP_SHORT(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + +static PyObject * +h_get(void *ptr, Py_ssize_t size) +{ + short val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromLong((long)val); +} + +static PyObject * +h_get_sw(void *ptr, Py_ssize_t size) +{ + short val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_SHORT(val); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +H_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned short x; + if (get_ulong(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(unsigned short, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +H_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned short field; + if (get_ulong(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_SHORT(field); + field = SET(unsigned short, field, val, size); + field = SWAP_SHORT(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + + +static PyObject * +H_get(void *ptr, Py_ssize_t size) +{ + unsigned short val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +H_get_sw(void *ptr, Py_ssize_t size) +{ + unsigned short val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_SHORT(val); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +i_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + int x; + if (get_long(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(int, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +i_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + int field; + if (get_long(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_INT(field); + field = SET(int, field, val, size); + field = SWAP_INT(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + + +static PyObject * +i_get(void *ptr, Py_ssize_t size) +{ + int val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +i_get_sw(void *ptr, Py_ssize_t size) +{ + int val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_INT(val); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +#ifndef MS_WIN32 +/* http://msdn.microsoft.com/en-us/library/cc237864.aspx */ +#define VARIANT_FALSE 0x0000 +#define VARIANT_TRUE 0xFFFF +#endif +/* short BOOL - VARIANT_BOOL */ +static PyObject * +vBOOL_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + switch (PyObject_IsTrue(value)) { + case -1: + return NULL; + case 0: + *(short int *)ptr = VARIANT_FALSE; + _RET(value); + default: + *(short int *)ptr = VARIANT_TRUE; + _RET(value); + } +} + +static PyObject * +vBOOL_get(void *ptr, Py_ssize_t size) +{ + return PyBool_FromLong((long)*(short int *)ptr); +} + +static PyObject * +bool_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + switch (PyObject_IsTrue(value)) { + case -1: + return NULL; + case 0: + *(_Bool *)ptr = 0; + _RET(value); + default: + *(_Bool *)ptr = 1; + _RET(value); + } +} + +static PyObject * +bool_get(void *ptr, Py_ssize_t size) +{ + return PyBool_FromLong((long)*(_Bool *)ptr); +} + +static PyObject * +I_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned int x; + if (get_ulong(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(unsigned int, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +I_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned int field; + if (get_ulong(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_INT(field); + field = SET(unsigned int, field, (unsigned int)val, size); + field = SWAP_INT(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + + +static PyObject * +I_get(void *ptr, Py_ssize_t size) +{ + unsigned int val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLong(val); +} + +static PyObject * +I_get_sw(void *ptr, Py_ssize_t size) +{ + unsigned int val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_INT(val); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLong(val); +} + +static PyObject * +l_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + long x; + if (get_long(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(long, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +l_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + long val; + long field; + if (get_long(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_LONG(field); + field = SET(long, field, val, size); + field = SWAP_LONG(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + + +static PyObject * +l_get(void *ptr, Py_ssize_t size) +{ + long val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +l_get_sw(void *ptr, Py_ssize_t size) +{ + long val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_LONG(val); + GET_BITFIELD(val, size); + return PyLong_FromLong(val); +} + +static PyObject * +L_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned long x; + if (get_ulong(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(unsigned long, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +L_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long val; + unsigned long field; + if (get_ulong(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_LONG(field); + field = SET(unsigned long, field, val, size); + field = SWAP_LONG(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + + +static PyObject * +L_get(void *ptr, Py_ssize_t size) +{ + unsigned long val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLong(val); +} + +static PyObject * +L_get_sw(void *ptr, Py_ssize_t size) +{ + unsigned long val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_LONG(val); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLong(val); +} + +static PyObject * +q_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long long val; + long long x; + if (get_longlong(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(long long, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +q_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + long long val; + long long field; + if (get_longlong(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_LONG_LONG(field); + field = SET(long long, field, val, size); + field = SWAP_LONG_LONG(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + +static PyObject * +q_get(void *ptr, Py_ssize_t size) +{ + long long val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromLongLong(val); +} + +static PyObject * +q_get_sw(void *ptr, Py_ssize_t size) +{ + long long val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_LONG_LONG(val); + GET_BITFIELD(val, size); + return PyLong_FromLongLong(val); +} + +static PyObject * +Q_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long long val; + unsigned long long x; + if (get_ulonglong(value, &val) < 0) + return NULL; + memcpy(&x, ptr, sizeof(x)); + x = SET(long long, x, val, size); + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + unsigned long long val; + unsigned long long field; + if (get_ulonglong(value, &val) < 0) { + return NULL; + } + memcpy(&field, ptr, sizeof(field)); + field = SWAP_LONG_LONG(field); + field = SET(unsigned long long, field, val, size); + field = SWAP_LONG_LONG(field); + memcpy(ptr, &field, sizeof(field)); + _RET(value); +} + +static PyObject * +Q_get(void *ptr, Py_ssize_t size) +{ + unsigned long long val; + memcpy(&val, ptr, sizeof(val)); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLongLong(val); +} + +static PyObject * +Q_get_sw(void *ptr, Py_ssize_t size) +{ + unsigned long long val; + memcpy(&val, ptr, sizeof(val)); + val = SWAP_LONG_LONG(val); + GET_BITFIELD(val, size); + return PyLong_FromUnsignedLongLong(val); +} + +/***************************************************************** + * non-integer accessor methods, not supporting bit fields + */ + + +static PyObject * +g_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + long double x; + + x = PyFloat_AsDouble(value); + if (x == -1 && PyErr_Occurred()) + return NULL; + memcpy(ptr, &x, sizeof(long double)); + _RET(value); +} + +static PyObject * +g_get(void *ptr, Py_ssize_t size) +{ + long double val; + memcpy(&val, ptr, sizeof(long double)); + return PyFloat_FromDouble(val); +} + +static PyObject * +d_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + double x; + + x = PyFloat_AsDouble(value); + if (x == -1 && PyErr_Occurred()) + return NULL; + memcpy(ptr, &x, sizeof(double)); + _RET(value); +} + +static PyObject * +d_get(void *ptr, Py_ssize_t size) +{ + double val; + memcpy(&val, ptr, sizeof(val)); + return PyFloat_FromDouble(val); +} + +static PyObject * +d_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + double x; + + x = PyFloat_AsDouble(value); + if (x == -1 && PyErr_Occurred()) + return NULL; +#ifdef WORDS_BIGENDIAN + if (PyFloat_Pack8(x, ptr, 1)) + return NULL; +#else + if (PyFloat_Pack8(x, ptr, 0)) + return NULL; +#endif + _RET(value); +} + +static PyObject * +d_get_sw(void *ptr, Py_ssize_t size) +{ +#ifdef WORDS_BIGENDIAN + return PyFloat_FromDouble(PyFloat_Unpack8(ptr, 1)); +#else + return PyFloat_FromDouble(PyFloat_Unpack8(ptr, 0)); +#endif +} + +static PyObject * +f_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + float x; + + x = (float)PyFloat_AsDouble(value); + if (x == -1 && PyErr_Occurred()) + return NULL; + memcpy(ptr, &x, sizeof(x)); + _RET(value); +} + +static PyObject * +f_get(void *ptr, Py_ssize_t size) +{ + float val; + memcpy(&val, ptr, sizeof(val)); + return PyFloat_FromDouble(val); +} + +static PyObject * +f_set_sw(void *ptr, PyObject *value, Py_ssize_t size) +{ + float x; + + x = (float)PyFloat_AsDouble(value); + if (x == -1 && PyErr_Occurred()) + return NULL; +#ifdef WORDS_BIGENDIAN + if (PyFloat_Pack4(x, ptr, 1)) + return NULL; +#else + if (PyFloat_Pack4(x, ptr, 0)) + return NULL; +#endif + _RET(value); +} + +static PyObject * +f_get_sw(void *ptr, Py_ssize_t size) +{ +#ifdef WORDS_BIGENDIAN + return PyFloat_FromDouble(PyFloat_Unpack4(ptr, 1)); +#else + return PyFloat_FromDouble(PyFloat_Unpack4(ptr, 0)); +#endif +} + +/* + py_object refcounts: + + 1. If we have a py_object instance, O_get must Py_INCREF the returned + object, of course. If O_get is called from a function result, no py_object + instance is created - so callproc.c::GetResult has to call Py_DECREF. + + 2. The memory block in py_object owns a refcount. So, py_object must call + Py_DECREF on destruction. Maybe only when b_needsfree is non-zero. +*/ +static PyObject * +O_get(void *ptr, Py_ssize_t size) +{ + PyObject *ob = *(PyObject **)ptr; + if (ob == NULL) { + if (!PyErr_Occurred()) + /* Set an error if not yet set */ + PyErr_SetString(PyExc_ValueError, + "PyObject is NULL"); + return NULL; + } + return Py_NewRef(ob); +} + +static PyObject * +O_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + /* Hm, does the memory block need it's own refcount or not? */ + *(PyObject **)ptr = value; + return Py_NewRef(value); +} + + +static PyObject * +c_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) { + *(char *)ptr = PyBytes_AS_STRING(value)[0]; + _RET(value); + } + if (PyByteArray_Check(value) && PyByteArray_GET_SIZE(value) == 1) { + *(char *)ptr = PyByteArray_AS_STRING(value)[0]; + _RET(value); + } + if (PyLong_Check(value)) + { + long longval = PyLong_AsLong(value); + if (longval < 0 || longval >= 256) + goto error; + *(char *)ptr = (char)longval; + _RET(value); + } + error: + PyErr_Format(PyExc_TypeError, + "one character bytes, bytearray or integer expected"); + return NULL; +} + + +static PyObject * +c_get(void *ptr, Py_ssize_t size) +{ + return PyBytes_FromStringAndSize((char *)ptr, 1); +} + +/* u - a single wchar_t character */ +static PyObject * +u_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + Py_ssize_t len; + wchar_t chars[2]; + if (!PyUnicode_Check(value)) { + PyErr_Format(PyExc_TypeError, + "unicode string expected instead of %s instance", + Py_TYPE(value)->tp_name); + return NULL; + } else + Py_INCREF(value); + + len = PyUnicode_AsWideChar(value, chars, 2); + if (len != 1) { + Py_DECREF(value); + PyErr_SetString(PyExc_TypeError, + "one character unicode string expected"); + return NULL; + } + + *(wchar_t *)ptr = chars[0]; + Py_DECREF(value); + + _RET(value); +} + + +static PyObject * +u_get(void *ptr, Py_ssize_t size) +{ + return PyUnicode_FromWideChar((wchar_t *)ptr, 1); +} + +/* U - a unicode string */ +static PyObject * +U_get(void *ptr, Py_ssize_t size) +{ + Py_ssize_t len; + wchar_t *p; + + size /= sizeof(wchar_t); /* we count character units here, not bytes */ + + /* We need 'result' to be able to count the characters with wcslen, + since ptr may not be NUL terminated. If the length is smaller (if + it was actually NUL terminated, we construct a new one and throw + away the result. + */ + /* chop off at the first NUL character, if any. */ + p = (wchar_t*)ptr; + for (len = 0; len < size; ++len) { + if (!p[len]) + break; + } + + return PyUnicode_FromWideChar((wchar_t *)ptr, len); +} + +static PyObject * +U_set(void *ptr, PyObject *value, Py_ssize_t length) +{ + /* It's easier to calculate in characters than in bytes */ + length /= sizeof(wchar_t); + + if (!PyUnicode_Check(value)) { + PyErr_Format(PyExc_TypeError, + "unicode string expected instead of %s instance", + Py_TYPE(value)->tp_name); + return NULL; + } + + Py_ssize_t size = PyUnicode_AsWideChar(value, NULL, 0); + if (size < 0) { + return NULL; + } + // PyUnicode_AsWideChar() returns number of wchars including trailing null byte, + // when it is called with NULL. + size--; + assert(size >= 0); + if (size > length) { + PyErr_Format(PyExc_ValueError, + "string too long (%zd, maximum length %zd)", + size, length); + return NULL; + } + if (PyUnicode_AsWideChar(value, (wchar_t *)ptr, length) == -1) { + return NULL; + } + + return Py_NewRef(value); +} + + +static PyObject * +s_get(void *ptr, Py_ssize_t size) +{ + Py_ssize_t i; + char *p; + + p = (char *)ptr; + for (i = 0; i < size; ++i) { + if (*p++ == '\0') + break; + } + + return PyBytes_FromStringAndSize((char *)ptr, (Py_ssize_t)i); +} + +static PyObject * +s_set(void *ptr, PyObject *value, Py_ssize_t length) +{ + const char *data; + Py_ssize_t size; + + if(!PyBytes_Check(value)) { + PyErr_Format(PyExc_TypeError, + "expected bytes, %s found", + Py_TYPE(value)->tp_name); + return NULL; + } + + data = PyBytes_AS_STRING(value); + // bpo-39593: Use strlen() to truncate the string at the first null character. + size = strlen(data); + + if (size < length) { + /* This will copy the terminating NUL character + * if there is space for it. + */ + ++size; + } else if (size > length) { + PyErr_Format(PyExc_ValueError, + "bytes too long (%zd, maximum length %zd)", + size, length); + return NULL; + } + /* Also copy the terminating NUL character if there is space */ + memcpy((char *)ptr, data, size); + + _RET(value); +} + +static PyObject * +z_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + if (value == Py_None) { + *(char **)ptr = NULL; + return Py_NewRef(value); + } + if (PyBytes_Check(value)) { + *(const char **)ptr = PyBytes_AsString(value); + return Py_NewRef(value); + } else if (PyLong_Check(value)) { +#if SIZEOF_VOID_P == SIZEOF_LONG_LONG + *(char **)ptr = (char *)PyLong_AsUnsignedLongLongMask(value); +#else + *(char **)ptr = (char *)PyLong_AsUnsignedLongMask(value); +#endif + _RET(value); + } + PyErr_Format(PyExc_TypeError, + "bytes or integer address expected instead of %s instance", + Py_TYPE(value)->tp_name); + return NULL; +} + +static PyObject * +z_get(void *ptr, Py_ssize_t size) +{ + /* XXX What about invalid pointers ??? */ + if (*(void **)ptr) { + return PyBytes_FromStringAndSize(*(char **)ptr, + strlen(*(char **)ptr)); + } else { + Py_RETURN_NONE; + } +} + +static PyObject * +Z_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + PyObject *keep; + wchar_t *buffer; + Py_ssize_t bsize; + + if (value == Py_None) { + *(wchar_t **)ptr = NULL; + return Py_NewRef(value); + } + if (PyLong_Check(value)) { +#if SIZEOF_VOID_P == SIZEOF_LONG_LONG + *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value); +#else + *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value); +#endif + Py_RETURN_NONE; + } + if (!PyUnicode_Check(value)) { + PyErr_Format(PyExc_TypeError, + "unicode string or integer address expected instead of %s instance", + Py_TYPE(value)->tp_name); + return NULL; + } + + /* We must create a wchar_t* buffer from the unicode object, + and keep it alive */ + buffer = PyUnicode_AsWideCharString(value, &bsize); + if (!buffer) + return NULL; + keep = PyCapsule_New(buffer, CTYPES_CFIELD_CAPSULE_NAME_PYMEM, pymem_destructor); + if (!keep) { + PyMem_Free(buffer); + return NULL; + } + *(wchar_t **)ptr = buffer; + return keep; +} + +static PyObject * +Z_get(void *ptr, Py_ssize_t size) +{ + wchar_t *p; + p = *(wchar_t **)ptr; + if (p) { + return PyUnicode_FromWideChar(p, wcslen(p)); + } else { + Py_RETURN_NONE; + } +} + + +#ifdef MS_WIN32 +static PyObject * +BSTR_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + BSTR bstr; + + /* convert value into a PyUnicodeObject or NULL */ + if (Py_None == value) { + value = NULL; + } else if (!PyUnicode_Check(value)) { + PyErr_Format(PyExc_TypeError, + "unicode string expected instead of %s instance", + Py_TYPE(value)->tp_name); + return NULL; + } + + /* create a BSTR from value */ + if (value) { + Py_ssize_t wsize; + wchar_t *wvalue = PyUnicode_AsWideCharString(value, &wsize); + if (wvalue == NULL) { + return NULL; + } + if ((unsigned) wsize != wsize) { + PyErr_SetString(PyExc_ValueError, "String too long for BSTR"); + PyMem_Free(wvalue); + return NULL; + } + bstr = SysAllocStringLen(wvalue, (unsigned)wsize); + PyMem_Free(wvalue); + } else + bstr = NULL; + + /* free the previous contents, if any */ + if (*(BSTR *)ptr) + SysFreeString(*(BSTR *)ptr); + + /* and store it */ + *(BSTR *)ptr = bstr; + + /* We don't need to keep any other object */ + _RET(value); +} + + +static PyObject * +BSTR_get(void *ptr, Py_ssize_t size) +{ + BSTR p; + p = *(BSTR *)ptr; + if (p) + return PyUnicode_FromWideChar(p, SysStringLen(p)); + else { + /* Hm, it seems NULL pointer and zero length string are the + same in BSTR, see Don Box, p 81 + */ + Py_RETURN_NONE; + } +} +#endif + +static PyObject * +P_set(void *ptr, PyObject *value, Py_ssize_t size) +{ + void *v; + if (value == Py_None) { + *(void **)ptr = NULL; + _RET(value); + } + + if (!PyLong_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "cannot be converted to pointer"); + return NULL; + } + +#if SIZEOF_VOID_P <= SIZEOF_LONG + v = (void *)PyLong_AsUnsignedLongMask(value); +#else +#if SIZEOF_LONG_LONG < SIZEOF_VOID_P +# error "PyLong_AsVoidPtr: sizeof(long long) < sizeof(void*)" +#endif + v = (void *)PyLong_AsUnsignedLongLongMask(value); +#endif + + if (PyErr_Occurred()) + return NULL; + + *(void **)ptr = v; + _RET(value); +} + +static PyObject * +P_get(void *ptr, Py_ssize_t size) +{ + if (*(void **)ptr == NULL) { + Py_RETURN_NONE; + } + return PyLong_FromVoidPtr(*(void **)ptr); +} + +static struct fielddesc formattable[] = { + { 's', s_set, s_get, NULL}, + { 'b', b_set, b_get, NULL}, + { 'B', B_set, B_get, NULL}, + { 'c', c_set, c_get, NULL}, + { 'd', d_set, d_get, NULL, d_set_sw, d_get_sw}, + { 'g', g_set, g_get, NULL}, + { 'f', f_set, f_get, NULL, f_set_sw, f_get_sw}, + { 'h', h_set, h_get, NULL, h_set_sw, h_get_sw}, + { 'H', H_set, H_get, NULL, H_set_sw, H_get_sw}, + { 'i', i_set, i_get, NULL, i_set_sw, i_get_sw}, + { 'I', I_set, I_get, NULL, I_set_sw, I_get_sw}, + { 'l', l_set, l_get, NULL, l_set_sw, l_get_sw}, + { 'L', L_set, L_get, NULL, L_set_sw, L_get_sw}, + { 'q', q_set, q_get, NULL, q_set_sw, q_get_sw}, + { 'Q', Q_set, Q_get, NULL, Q_set_sw, Q_get_sw}, + { 'P', P_set, P_get, NULL}, + { 'z', z_set, z_get, NULL}, + { 'u', u_set, u_get, NULL}, + { 'U', U_set, U_get, NULL}, + { 'Z', Z_set, Z_get, NULL}, +#ifdef MS_WIN32 + { 'X', BSTR_set, BSTR_get, NULL}, +#endif + { 'v', vBOOL_set, vBOOL_get, NULL}, +#if SIZEOF__BOOL == SIZEOF_INT + { '?', bool_set, bool_get, NULL, I_set_sw, I_get_sw}, +#elif SIZEOF__BOOL == SIZEOF_LONG + { '?', bool_set, bool_get, NULL, L_set_sw, L_get_sw}, +#elif SIZEOF__BOOL == SIZEOF_LONG_LONG + { '?', bool_set, bool_get, NULL, Q_set_sw, Q_get_sw}, +#else + { '?', bool_set, bool_get, NULL}, +#endif /* SIZEOF__BOOL */ + { 'O', O_set, O_get, NULL}, + { 0, NULL, NULL, NULL}, +}; + +/* + Ideas: Implement VARIANT in this table, using 'V' code. + Use '?' as code for BOOL. +*/ + +/* Delayed initialization. Windows cannot statically reference dynamically + loaded addresses from DLLs. */ +void +_ctypes_init_fielddesc(void) +{ + struct fielddesc *fd = formattable; + for (; fd->code; ++fd) { + switch (fd->code) { + case 's': fd->pffi_type = &ffi_type_pointer; break; + case 'b': fd->pffi_type = &ffi_type_schar; break; + case 'B': fd->pffi_type = &ffi_type_uchar; break; + case 'c': fd->pffi_type = &ffi_type_schar; break; + case 'd': fd->pffi_type = &ffi_type_double; break; + case 'g': fd->pffi_type = &ffi_type_longdouble; break; + case 'f': fd->pffi_type = &ffi_type_float; break; + case 'h': fd->pffi_type = &ffi_type_sshort; break; + case 'H': fd->pffi_type = &ffi_type_ushort; break; + case 'i': fd->pffi_type = &ffi_type_sint; break; + case 'I': fd->pffi_type = &ffi_type_uint; break; + /* XXX Hm, sizeof(int) == sizeof(long) doesn't hold on every platform */ + /* As soon as we can get rid of the type codes, this is no longer a problem */ + #if SIZEOF_LONG == 4 + case 'l': fd->pffi_type = &ffi_type_sint32; break; + case 'L': fd->pffi_type = &ffi_type_uint32; break; + #elif SIZEOF_LONG == 8 + case 'l': fd->pffi_type = &ffi_type_sint64; break; + case 'L': fd->pffi_type = &ffi_type_uint64; break; + #else + #error + #endif + #if SIZEOF_LONG_LONG == 8 + case 'q': fd->pffi_type = &ffi_type_sint64; break; + case 'Q': fd->pffi_type = &ffi_type_uint64; break; + #else + #error + #endif + case 'P': fd->pffi_type = &ffi_type_pointer; break; + case 'z': fd->pffi_type = &ffi_type_pointer; break; + case 'u': + if (sizeof(wchar_t) == sizeof(short)) + fd->pffi_type = &ffi_type_sshort; + else if (sizeof(wchar_t) == sizeof(int)) + fd->pffi_type = &ffi_type_sint; + else if (sizeof(wchar_t) == sizeof(long)) + fd->pffi_type = &ffi_type_slong; + else + Py_UNREACHABLE(); + break; + case 'U': fd->pffi_type = &ffi_type_pointer; break; + case 'Z': fd->pffi_type = &ffi_type_pointer; break; + #ifdef MS_WIN32 + case 'X': fd->pffi_type = &ffi_type_pointer; break; + #endif + case 'v': fd->pffi_type = &ffi_type_sshort; break; + #if SIZEOF__BOOL == 1 + case '?': fd->pffi_type = &ffi_type_uchar; break; /* Also fallback for no native _Bool support */ + #elif SIZEOF__BOOL == SIZEOF_SHORT + case '?': fd->pffi_type = &ffi_type_ushort; break; + #elif SIZEOF__BOOL == SIZEOF_INT + case '?': fd->pffi_type = &ffi_type_uint; break; + #elif SIZEOF__BOOL == SIZEOF_LONG + case '?': fd->pffi_type = &ffi_type_ulong; break; + #elif SIZEOF__BOOL == SIZEOF_LONG_LONG + case '?': fd->pffi_type = &ffi_type_ulong; break; + #endif /* SIZEOF__BOOL */ + case 'O': fd->pffi_type = &ffi_type_pointer; break; + default: + Py_UNREACHABLE(); + } + } + +} + +struct fielddesc * +_ctypes_get_fielddesc(const char *fmt) +{ + static int initialized = 0; + struct fielddesc *table = formattable; + + if (!initialized) { + initialized = 1; + _ctypes_init_fielddesc(); + } + + for (; table->code; ++table) { + if (table->code == fmt[0]) + return table; + } + return NULL; +} + +/*---------------- EOF ----------------*/ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/ctypes.h b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/ctypes.h new file mode 100644 index 0000000000..4e0045024a --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/ctypes.h @@ -0,0 +1,427 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +#if 1 // GraalPy change to support _Py_ID usages in this file +#ifdef MS_WIN32 +#define _Py_ID(name) PyUnicode_FromString(#name) +#else +// This is a GCC extension +#define _Py_ID(name) ({ \ + static PyObject *name ## _id = NULL; \ + if (!name ## _id) name ## _id = PyUnicode_FromString(#name); \ + name ## _id; }) +#endif +#endif + +#if defined (__SVR4) && defined (__sun) +# include +#endif + +#ifndef MS_WIN32 +#define max(a, b) ((a) > (b) ? (a) : (b)) +#define min(a, b) ((a) < (b) ? (a) : (b)) + +#define PARAMFLAG_FIN 0x1 +#define PARAMFLAG_FOUT 0x2 +#define PARAMFLAG_FLCID 0x4 +#endif + +/* + * bpo-13097: Max number of arguments CFuncPtr._argtypes_ and + * _ctypes_callproc() will accept. + * + * This limit is enforced for the `alloca()` call in `_ctypes_callproc`, + * to avoid allocating a massive buffer on the stack. + */ +#ifndef CTYPES_MAX_ARGCOUNT + #ifdef __EMSCRIPTEN__ + #define CTYPES_MAX_ARGCOUNT 1000 + #else + #define CTYPES_MAX_ARGCOUNT 1024 + #endif +#endif + +#if defined(__has_builtin) +#if __has_builtin(__builtin_available) +#define HAVE_BUILTIN_AVAILABLE 1 +#endif +#endif + +typedef struct { + PyTypeObject *DictRemover_Type; + PyTypeObject *PyCArg_Type; + PyTypeObject *PyCField_Type; + PyTypeObject *PyCThunk_Type; +#ifdef MS_WIN32 + PyTypeObject *PyComError_Type; +#endif + PyTypeObject *StructParam_Type; +} ctypes_state; + +extern ctypes_state global_state; + +#define GLOBAL_STATE() (&global_state) + +extern PyType_Spec carg_spec; +extern PyType_Spec cfield_spec; +extern PyType_Spec cthunk_spec; + +typedef struct tagPyCArgObject PyCArgObject; +typedef struct tagCDataObject CDataObject; +typedef PyObject *(* GETFUNC)(void *, Py_ssize_t size); +typedef PyObject *(* SETFUNC)(void *, PyObject *value, Py_ssize_t size); +typedef PyCArgObject *(* PARAMFUNC)(CDataObject *obj); + +/* A default buffer in CDataObject, which can be used for small C types. If +this buffer is too small, PyMem_Malloc will be called to create a larger one, +and this one is not used. + +Making CDataObject a variable size object would be a better solution, but more +difficult in the presence of PyCFuncPtrObject. Maybe later. +*/ +union value { + char c[16]; + short s; + int i; + long l; + float f; + double d; + long long ll; + long double D; +}; + +/* + Hm. Are there CDataObject's which do not need the b_objects member? In + this case we probably should introduce b_flags to mark it as present... If + b_objects is not present/unused b_length is unneeded as well. +*/ + +struct tagCDataObject { + PyObject_HEAD + char *b_ptr; /* pointer to memory block */ + int b_needsfree; /* need _we_ free the memory? */ + CDataObject *b_base; /* pointer to base object or NULL */ + Py_ssize_t b_size; /* size of memory block in bytes */ + Py_ssize_t b_length; /* number of references we need */ + Py_ssize_t b_index; /* index of this object into base's + b_object list */ + PyObject *b_objects; /* dictionary of references we need to keep, or Py_None */ + union value b_value; +}; + +typedef struct { + PyObject_VAR_HEAD + ffi_closure *pcl_write; /* the C callable, writeable */ + void *pcl_exec; /* the C callable, executable */ + ffi_cif cif; + int flags; + PyObject *converters; + PyObject *callable; + PyObject *restype; + SETFUNC setfunc; + ffi_type *ffi_restype; + ffi_type *atypes[1]; +} CThunkObject; +#define CThunk_CheckExact(st, v) Py_IS_TYPE(v, st->PyCThunk_Type) + +typedef struct { + /* First part identical to tagCDataObject */ + PyObject_HEAD + char *b_ptr; /* pointer to memory block */ + int b_needsfree; /* need _we_ free the memory? */ + CDataObject *b_base; /* pointer to base object or NULL */ + Py_ssize_t b_size; /* size of memory block in bytes */ + Py_ssize_t b_length; /* number of references we need */ + Py_ssize_t b_index; /* index of this object into base's + b_object list */ + PyObject *b_objects; /* list of references we need to keep */ + union value b_value; + /* end of tagCDataObject, additional fields follow */ + + CThunkObject *thunk; + PyObject *callable; + + /* These two fields will override the ones in the type's stgdict if + they are set */ + PyObject *converters; + PyObject *argtypes; + PyObject *restype; + PyObject *checker; + PyObject *errcheck; +#ifdef MS_WIN32 + int index; + GUID *iid; +#endif + PyObject *paramflags; +} PyCFuncPtrObject; + +extern PyTypeObject PyCStgDict_Type; +#define PyCStgDict_CheckExact(v) Py_IS_TYPE(v, &PyCStgDict_Type) +#define PyCStgDict_Check(v) PyObject_TypeCheck(v, &PyCStgDict_Type) + +extern int PyCStructUnionType_update_stgdict(PyObject *fields, PyObject *type, int isStruct); +extern int PyType_stginfo(PyTypeObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); +extern int PyObject_stginfo(PyObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); + + + +extern PyTypeObject PyCData_Type; +#define CDataObject_CheckExact(v) Py_IS_TYPE(v, &PyCData_Type) +#define CDataObject_Check(v) PyObject_TypeCheck(v, &PyCData_Type) +#define _CDataObject_HasExternalBuffer(v) ((v)->b_ptr != (char *)&(v)->b_value) + +extern PyTypeObject PyCSimpleType_Type; +#define PyCSimpleTypeObject_CheckExact(v) Py_IS_TYPE(v, &PyCSimpleType_Type) +#define PyCSimpleTypeObject_Check(v) PyObject_TypeCheck(v, &PyCSimpleType_Type) + +extern struct fielddesc *_ctypes_get_fielddesc(const char *fmt); + + +extern PyObject * +PyCField_FromDesc(PyObject *desc, Py_ssize_t index, + Py_ssize_t *pfield_size, int bitsize, int *pbitofs, + Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign, + int pack, int is_big_endian); + +extern PyObject *PyCData_AtAddress(PyObject *type, void *buf); +extern PyObject *PyCData_FromBytes(PyObject *type, char *data, Py_ssize_t length); + +extern PyTypeObject PyCArrayType_Type; +extern PyTypeObject PyCArray_Type; +extern PyTypeObject PyCPointerType_Type; +extern PyTypeObject PyCPointer_Type; +extern PyTypeObject PyCFuncPtr_Type; +extern PyTypeObject PyCFuncPtrType_Type; +extern PyTypeObject PyCStructType_Type; + +#define PyCArrayTypeObject_Check(v) PyObject_TypeCheck(v, &PyCArrayType_Type) +#define ArrayObject_Check(v) PyObject_TypeCheck(v, &PyCArray_Type) +#define PointerObject_Check(v) PyObject_TypeCheck(v, &PyCPointer_Type) +#define PyCPointerTypeObject_Check(v) PyObject_TypeCheck(v, &PyCPointerType_Type) +#define PyCFuncPtrObject_Check(v) PyObject_TypeCheck(v, &PyCFuncPtr_Type) +#define PyCFuncPtrTypeObject_Check(v) PyObject_TypeCheck(v, &PyCFuncPtrType_Type) +#define PyCStructTypeObject_Check(v) PyObject_TypeCheck(v, &PyCStructType_Type) + +extern PyObject * +PyCArrayType_from_ctype(PyObject *itemtype, Py_ssize_t length); + +extern PyMethodDef _ctypes_module_methods[]; + +extern CThunkObject *_ctypes_alloc_callback(PyObject *callable, + PyObject *converters, + PyObject *restype, + int flags); +/* a table entry describing a predefined ctypes type */ +struct fielddesc { + char code; + SETFUNC setfunc; + GETFUNC getfunc; + ffi_type *pffi_type; /* always statically allocated */ + SETFUNC setfunc_swapped; + GETFUNC getfunc_swapped; +}; + +typedef struct { + PyObject_HEAD + Py_ssize_t offset; + Py_ssize_t size; + Py_ssize_t index; /* Index into CDataObject's + object array */ + PyObject *proto; /* a type or NULL */ + GETFUNC getfunc; /* getter function if proto is NULL */ + SETFUNC setfunc; /* setter function if proto is NULL */ + int anonymous; +} CFieldObject; + +/* A subclass of PyDictObject, used as the instance dictionary of ctypes + metatypes */ +typedef struct { + PyDictObject dict; /* first part identical to PyDictObject */ +/* The size and align fields are unneeded, they are in ffi_type as well. As + an experiment shows, it's trivial to get rid of them, the only thing to + remember is that in PyCArrayType_new the ffi_type fields must be filled in - + so far it was unneeded because libffi doesn't support arrays at all + (because they are passed as pointers to function calls anyway). But it's + too much risk to change that now, and there are other fields which doesn't + belong into this structure anyway. Maybe in ctypes 2.0... (ctypes 2000?) +*/ + Py_ssize_t size; /* number of bytes */ + Py_ssize_t align; /* alignment requirements */ + Py_ssize_t length; /* number of fields */ + ffi_type ffi_type_pointer; + PyObject *proto; /* Only for Pointer/ArrayObject */ + SETFUNC setfunc; /* Only for simple objects */ + GETFUNC getfunc; /* Only for simple objects */ + PARAMFUNC paramfunc; + + /* Following fields only used by PyCFuncPtrType_Type instances */ + PyObject *argtypes; /* tuple of CDataObjects */ + PyObject *converters; /* tuple([t.from_param for t in argtypes]) */ + PyObject *restype; /* CDataObject or NULL */ + PyObject *checker; + int flags; /* calling convention and such */ + + /* pep3118 fields, pointers need PyMem_Free */ + char *format; + int ndim; + Py_ssize_t *shape; +/* Py_ssize_t *strides; */ /* unused in ctypes */ +/* Py_ssize_t *suboffsets; */ /* unused in ctypes */ + +} StgDictObject; + +/**************************************************************** + StgDictObject fields + + setfunc and getfunc is only set for simple data types, it is copied from the + corresponding fielddesc entry. These are functions to set and get the value + in a memory block. + They should probably by used by other types as well. + + proto is only used for Pointer and Array types - it points to the item type + object. + + Probably all the magic ctypes methods (like from_param) should have C + callable wrappers in the StgDictObject. For simple data type, for example, + the fielddesc table could have entries for C codec from_param functions or + other methods as well, if a subtype overrides this method in Python at + construction time, or assigns to it later, tp_setattro should update the + StgDictObject function to a generic one. + + Currently, PyCFuncPtr types have 'converters' and 'checker' entries in their + type dict. They are only used to cache attributes from other entries, which + is wrong. + + One use case is the .value attribute that all simple types have. But some + complex structures, like VARIANT, represent a single value also, and should + have this attribute. + + Another use case is a _check_retval_ function, which is called when a ctypes + type is used as return type of a function to validate and compute the return + value. + + Common ctypes protocol: + + - setfunc: store a python value in a memory block + - getfunc: convert data from a memory block into a python value + + - checkfunc: validate and convert a return value from a function call + - toparamfunc: convert a python value into a function argument + +*****************************************************************/ + +/* May return NULL, but does not set an exception! */ +extern StgDictObject *PyType_stgdict(PyObject *obj); + +/* May return NULL, but does not set an exception! */ +extern StgDictObject *PyObject_stgdict(PyObject *self); + +extern int PyCStgDict_clone(StgDictObject *src, StgDictObject *dst); + +typedef int(* PPROC)(void); + +PyObject *_ctypes_callproc(PPROC pProc, + PyObject *arguments, +#ifdef MS_WIN32 + IUnknown *pIUnk, + GUID *iid, +#endif + int flags, + PyObject *argtypes, + PyObject *restype, + PyObject *checker); + + +#define FUNCFLAG_STDCALL 0x0 +#define FUNCFLAG_CDECL 0x1 +#define FUNCFLAG_HRESULT 0x2 +#define FUNCFLAG_PYTHONAPI 0x4 +#define FUNCFLAG_USE_ERRNO 0x8 +#define FUNCFLAG_USE_LASTERROR 0x10 + +#define TYPEFLAG_ISPOINTER 0x100 +#define TYPEFLAG_HASPOINTER 0x200 +#define TYPEFLAG_HASUNION 0x400 +#define TYPEFLAG_HASBITFIELD 0x800 + +#define DICTFLAG_FINAL 0x1000 + +struct tagPyCArgObject { + PyObject_HEAD + ffi_type *pffi_type; + char tag; + union { + char c; + char b; + short h; + int i; + long l; + long long q; + long double D; + double d; + float f; + void *p; + } value; + PyObject *obj; + Py_ssize_t size; /* for the 'V' tag */ +}; + +#define PyCArg_CheckExact(st, v) Py_IS_TYPE(v, st->PyCArg_Type) +extern PyCArgObject *PyCArgObject_new(void); + +extern PyObject * +PyCData_get(PyObject *type, GETFUNC getfunc, PyObject *src, + Py_ssize_t index, Py_ssize_t size, char *ptr); + +extern int +PyCData_set(PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value, + Py_ssize_t index, Py_ssize_t size, char *ptr); + +extern void _ctypes_extend_error(PyObject *exc_class, const char *fmt, ...); + +struct basespec { + CDataObject *base; + Py_ssize_t index; + char *adr; +}; + +extern char basespec_string[]; + +extern ffi_type *_ctypes_get_ffi_type(PyObject *obj); + +/* exception classes */ +extern PyObject *PyExc_ArgError; + +extern char *_ctypes_conversion_encoding; +extern char *_ctypes_conversion_errors; + + +extern void _ctypes_free_closure(void *); +extern void *_ctypes_alloc_closure(void); + +extern PyObject *PyCData_FromBaseObj(PyObject *type, PyObject *base, Py_ssize_t index, char *adr); +extern char *_ctypes_alloc_format_string(const char *prefix, const char *suffix); +extern char *_ctypes_alloc_format_string_with_shape(int ndim, + const Py_ssize_t *shape, + const char *prefix, const char *suffix); + +extern int _ctypes_simple_instance(PyObject *obj); + +extern PyObject *_ctypes_ptrtype_cache; +PyObject *_ctypes_get_errobj(int **pspace); + +#ifdef USING_MALLOC_CLOSURE_DOT_C +void Py_ffi_closure_free(void *p); +void *Py_ffi_closure_alloc(size_t size, void** codeloc); +#else +#define Py_ffi_closure_free ffi_closure_free +#define Py_ffi_closure_alloc ffi_closure_alloc +#endif + +/* + Local Variables: + compile-command: "python setup.py -q build install --home ~" + End: +*/ diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/malloc_closure.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/malloc_closure.c new file mode 100644 index 0000000000..3cbb69ba74 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/malloc_closure.c @@ -0,0 +1,152 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#include +#include +#ifdef MS_WIN32 +#include +#else +#include +#include +# if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) +# define MAP_ANONYMOUS MAP_ANON +# endif +#endif +#include "ctypes.h" + +/* BLOCKSIZE can be adjusted. Larger blocksize will take a larger memory + overhead, but allocate less blocks from the system. It may be that some + systems have a limit of how many mmap'd blocks can be open. +*/ + +#define BLOCKSIZE _pagesize + +/* #define MALLOC_CLOSURE_DEBUG */ /* enable for some debugging output */ + + +/******************************************************************/ + +typedef union _tagITEM { + ffi_closure closure; + union _tagITEM *next; +} ITEM; + +static ITEM *free_list; +static int _pagesize; + +static void more_core(void) +{ + ITEM *item; + int count, i; + +/* determine the pagesize */ +#ifdef MS_WIN32 + if (!_pagesize) { + SYSTEM_INFO systeminfo; + GetSystemInfo(&systeminfo); + _pagesize = systeminfo.dwPageSize; + } +#else + if (!_pagesize) { +#ifdef _SC_PAGESIZE + _pagesize = sysconf(_SC_PAGESIZE); +#else + _pagesize = getpagesize(); +#endif + } +#endif + + /* calculate the number of nodes to allocate */ + count = BLOCKSIZE / sizeof(ITEM); + + /* allocate a memory block */ +#ifdef MS_WIN32 + item = (ITEM *)VirtualAlloc(NULL, + count * sizeof(ITEM), + MEM_COMMIT, + PAGE_EXECUTE_READWRITE); + if (item == NULL) + return; +#else + item = (ITEM *)mmap(NULL, + count * sizeof(ITEM), + PROT_READ | PROT_WRITE | PROT_EXEC, + MAP_PRIVATE | MAP_ANONYMOUS, + -1, + 0); + if (item == (void *)MAP_FAILED) + return; +#endif + +#ifdef MALLOC_CLOSURE_DEBUG + printf("block at %p allocated (%d bytes), %d ITEMs\n", + item, count * (int)sizeof(ITEM), count); +#endif + /* put them into the free list */ + for (i = 0; i < count; ++i) { + item->next = free_list; + free_list = item; + ++item; + } +} + +/******************************************************************/ + +/* put the item back into the free list */ +void Py_ffi_closure_free(void *p) +{ +#ifdef HAVE_FFI_CLOSURE_ALLOC +#ifdef USING_APPLE_OS_LIBFFI +# ifdef HAVE_BUILTIN_AVAILABLE + if (__builtin_available(macos 10.15, ios 13, watchos 6, tvos 13, *)) { +# else + if (ffi_closure_free != NULL) { +# endif +#endif + ffi_closure_free(p); + return; +#ifdef USING_APPLE_OS_LIBFFI + } +#endif +#endif + ITEM *item = (ITEM *)p; + item->next = free_list; + free_list = item; +} + +/* return one item from the free list, allocating more if needed */ +void *Py_ffi_closure_alloc(size_t size, void** codeloc) +{ +#ifdef HAVE_FFI_CLOSURE_ALLOC +#ifdef USING_APPLE_OS_LIBFFI +# ifdef HAVE_BUILTIN_AVAILABLE + if (__builtin_available(macos 10.15, ios 13, watchos 6, tvos 13, *)) { +# else + if (ffi_closure_alloc != NULL) { +# endif +#endif + return ffi_closure_alloc(size, codeloc); +#ifdef USING_APPLE_OS_LIBFFI + } +#endif +#endif + ITEM *item; + if (!free_list) + more_core(); + if (!free_list) + return NULL; + item = free_list; + free_list = item->next; +#ifdef _M_ARM + // set Thumb bit so that blx is called correctly + *codeloc = (ITEM*)((uintptr_t)item | 1); +#else + *codeloc = (void *)item; +#endif + return (void *)item; +} diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes/stgdict.c b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/stgdict.c new file mode 100644 index 0000000000..5d96e1b04a --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/modules/_ctypes/stgdict.c @@ -0,0 +1,969 @@ +/* Copyright (c) 2025, Oracle and/or its affiliates. + * Copyright (C) 1996-2025 Python Software Foundation + * + * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 + */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif + +#include "Python.h" +// windows.h must be included before pycore internal headers +#ifdef MS_WIN32 +# include +#endif + +#include "pycore_call.h" // _PyObject_CallNoArgs() +#include +#ifdef MS_WIN32 +# include +#endif +#include "ctypes.h" + +/******************************************************************/ +/* + StdDict - a dictionary subclass, containing additional C accessible fields + + XXX blabla more +*/ + +/* Seems we need this, otherwise we get problems when calling + * PyDict_SetItem() (ma_lookup is NULL) + */ +static int +PyCStgDict_init(StgDictObject *self, PyObject *args, PyObject *kwds) +{ + if (PyDict_Type.tp_init((PyObject *)self, args, kwds) < 0) + return -1; + self->format = NULL; + self->ndim = 0; + self->shape = NULL; + return 0; +} + +static int +PyCStgDict_clear(StgDictObject *self) +{ + Py_CLEAR(self->proto); + Py_CLEAR(self->argtypes); + Py_CLEAR(self->converters); + Py_CLEAR(self->restype); + Py_CLEAR(self->checker); + return 0; +} + +static void +PyCStgDict_dealloc(StgDictObject *self) +{ + PyCStgDict_clear(self); + PyMem_Free(self->format); + PyMem_Free(self->shape); + PyMem_Free(self->ffi_type_pointer.elements); + PyDict_Type.tp_dealloc((PyObject *)self); +} + +static PyObject * +PyCStgDict_sizeof(StgDictObject *self, void *unused) +{ + Py_ssize_t res; + + // GraalPy change: _PyDict_SizeOf -> PyObject_SIZE + res = _PyObject_SIZE(Py_TYPE(self)); + res += sizeof(StgDictObject) - sizeof(PyDictObject); + if (self->format) + res += strlen(self->format) + 1; + res += self->ndim * sizeof(Py_ssize_t); + if (self->ffi_type_pointer.elements) + res += (self->length + 1) * sizeof(ffi_type *); + return PyLong_FromSsize_t(res); +} + +int +PyCStgDict_clone(StgDictObject *dst, StgDictObject *src) +{ + char *d, *s; + Py_ssize_t size; + + PyCStgDict_clear(dst); + PyMem_Free(dst->ffi_type_pointer.elements); + PyMem_Free(dst->format); + dst->format = NULL; + PyMem_Free(dst->shape); + dst->shape = NULL; + dst->ffi_type_pointer.elements = NULL; + + d = (char *)dst; + s = (char *)src; + memcpy(d + sizeof(PyDictObject), + s + sizeof(PyDictObject), + sizeof(StgDictObject) - sizeof(PyDictObject)); + + Py_XINCREF(dst->proto); + Py_XINCREF(dst->argtypes); + Py_XINCREF(dst->converters); + Py_XINCREF(dst->restype); + Py_XINCREF(dst->checker); + + if (src->format) { + dst->format = PyMem_Malloc(strlen(src->format) + 1); + if (dst->format == NULL) { + PyErr_NoMemory(); + return -1; + } + strcpy(dst->format, src->format); + } + if (src->shape) { + dst->shape = PyMem_Malloc(sizeof(Py_ssize_t) * src->ndim); + if (dst->shape == NULL) { + PyErr_NoMemory(); + return -1; + } + memcpy(dst->shape, src->shape, + sizeof(Py_ssize_t) * src->ndim); + } + + if (src->ffi_type_pointer.elements == NULL) + return 0; + size = sizeof(ffi_type *) * (src->length + 1); + dst->ffi_type_pointer.elements = PyMem_Malloc(size); + if (dst->ffi_type_pointer.elements == NULL) { + PyErr_NoMemory(); + return -1; + } + memcpy(dst->ffi_type_pointer.elements, + src->ffi_type_pointer.elements, + size); + return 0; +} + +static struct PyMethodDef PyCStgDict_methods[] = { + {"__sizeof__", (PyCFunction)PyCStgDict_sizeof, METH_NOARGS}, + {NULL, NULL} /* sentinel */ +}; + +PyTypeObject PyCStgDict_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + "StgDict", + sizeof(StgDictObject), + 0, + (destructor)PyCStgDict_dealloc, /* tp_dealloc */ + 0, /* tp_vectorcall_offset */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_as_async */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PyCStgDict_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)PyCStgDict_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ +}; + +/* May return NULL, but does not set an exception! */ +StgDictObject * +PyType_stgdict(PyObject *obj) +{ + PyTypeObject *type; + + if (!PyType_Check(obj)) + return NULL; + type = (PyTypeObject *)obj; + if (!type->tp_dict || !PyCStgDict_CheckExact(type->tp_dict)) + return NULL; + return (StgDictObject *)type->tp_dict; +} + +/* May return NULL, but does not set an exception! */ +/* + This function should be as fast as possible, so we don't call PyType_stgdict + above but inline the code, and avoid the PyType_Check(). +*/ +StgDictObject * +PyObject_stgdict(PyObject *self) +{ + PyTypeObject *type = Py_TYPE(self); + if (!type->tp_dict || !PyCStgDict_CheckExact(type->tp_dict)) + return NULL; + return (StgDictObject *)type->tp_dict; +} + +/* descr is the descriptor for a field marked as anonymous. Get all the + _fields_ descriptors from descr->proto, create new descriptors with offset + and index adjusted, and stuff them into type. + */ +static int +MakeFields(PyObject *type, CFieldObject *descr, + Py_ssize_t index, Py_ssize_t offset) +{ + Py_ssize_t i; + PyObject *fields; + PyObject *fieldlist; + + fields = PyObject_GetAttrString(descr->proto, "_fields_"); + if (fields == NULL) + return -1; + fieldlist = PySequence_Fast(fields, "_fields_ must be a sequence"); + Py_DECREF(fields); + if (fieldlist == NULL) + return -1; + + ctypes_state *st = GLOBAL_STATE(); + PyTypeObject *cfield_tp = st->PyCField_Type; + for (i = 0; i < PySequence_Fast_GET_SIZE(fieldlist); ++i) { + PyObject *pair = PySequence_Fast_GET_ITEM(fieldlist, i); /* borrowed */ + PyObject *fname, *ftype, *bits; + CFieldObject *fdescr; + CFieldObject *new_descr; + /* Convert to PyArg_UnpackTuple... */ + if (!PyArg_ParseTuple(pair, "OO|O", &fname, &ftype, &bits)) { + Py_DECREF(fieldlist); + return -1; + } + fdescr = (CFieldObject *)PyObject_GetAttr(descr->proto, fname); + if (fdescr == NULL) { + Py_DECREF(fieldlist); + return -1; + } + if (!Py_IS_TYPE(fdescr, cfield_tp)) { + PyErr_SetString(PyExc_TypeError, "unexpected type"); + Py_DECREF(fdescr); + Py_DECREF(fieldlist); + return -1; + } + if (fdescr->anonymous) { + int rc = MakeFields(type, fdescr, + index + fdescr->index, + offset + fdescr->offset); + Py_DECREF(fdescr); + if (rc == -1) { + Py_DECREF(fieldlist); + return -1; + } + continue; + } + new_descr = (CFieldObject *)cfield_tp->tp_alloc(cfield_tp, 0); + if (new_descr == NULL) { + Py_DECREF(fdescr); + Py_DECREF(fieldlist); + return -1; + } + assert(Py_IS_TYPE(new_descr, cfield_tp)); + new_descr->size = fdescr->size; + new_descr->offset = fdescr->offset + offset; + new_descr->index = fdescr->index + index; + new_descr->proto = Py_XNewRef(fdescr->proto); + new_descr->getfunc = fdescr->getfunc; + new_descr->setfunc = fdescr->setfunc; + + Py_DECREF(fdescr); + + if (-1 == PyObject_SetAttr(type, fname, (PyObject *)new_descr)) { + Py_DECREF(fieldlist); + Py_DECREF(new_descr); + return -1; + } + Py_DECREF(new_descr); + } + Py_DECREF(fieldlist); + return 0; +} + +/* Iterate over the names in the type's _anonymous_ attribute, if present, + */ +static int +MakeAnonFields(PyObject *type) +{ + PyObject *anon; + PyObject *anon_names; + Py_ssize_t i; + + if (_PyObject_LookupAttr(type, _Py_ID(_anonymous_), &anon) < 0) { + return -1; + } + if (anon == NULL) { + return 0; + } + anon_names = PySequence_Fast(anon, "_anonymous_ must be a sequence"); + Py_DECREF(anon); + if (anon_names == NULL) + return -1; + + ctypes_state *st = GLOBAL_STATE(); + PyTypeObject *cfield_tp = st->PyCField_Type; + for (i = 0; i < PySequence_Fast_GET_SIZE(anon_names); ++i) { + PyObject *fname = PySequence_Fast_GET_ITEM(anon_names, i); /* borrowed */ + CFieldObject *descr = (CFieldObject *)PyObject_GetAttr(type, fname); + if (descr == NULL) { + Py_DECREF(anon_names); + return -1; + } + if (!Py_IS_TYPE(descr, cfield_tp)) { + PyErr_Format(PyExc_AttributeError, + "'%U' is specified in _anonymous_ but not in " + "_fields_", + fname); + Py_DECREF(anon_names); + Py_DECREF(descr); + return -1; + } + descr->anonymous = 1; + + /* descr is in the field descriptor. */ + if (-1 == MakeFields(type, (CFieldObject *)descr, + ((CFieldObject *)descr)->index, + ((CFieldObject *)descr)->offset)) { + Py_DECREF(descr); + Py_DECREF(anon_names); + return -1; + } + Py_DECREF(descr); + } + + Py_DECREF(anon_names); + return 0; +} + +/* + Allocate a memory block for a pep3118 format string, copy prefix (if + non-null) into it and append `{padding}x` to the end. + Returns NULL on failure, with the error indicator set. +*/ +char * +_ctypes_alloc_format_padding(const char *prefix, Py_ssize_t padding) +{ + /* int64 decimal characters + x + null */ + char buf[19 + 1 + 1]; + + assert(padding > 0); + + if (padding == 1) { + /* Use x instead of 1x, for brevity */ + return _ctypes_alloc_format_string(prefix, "x"); + } + + int ret = PyOS_snprintf(buf, sizeof(buf), "%zdx", padding); (void)ret; + assert(0 <= ret && ret < (Py_ssize_t)sizeof(buf)); + return _ctypes_alloc_format_string(prefix, buf); +} + +/* + Retrieve the (optional) _pack_ attribute from a type, the _fields_ attribute, + and create an StgDictObject. Used for Structure and Union subclasses. +*/ +int +PyCStructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct) +{ + StgDictObject *stgdict, *basedict; + Py_ssize_t len, offset, size, align, i; + Py_ssize_t union_size, total_align, aligned_size; + Py_ssize_t field_size = 0; + int bitofs; + PyObject *tmp; + int pack; + Py_ssize_t ffi_ofs; + int big_endian; + int arrays_seen = 0; + + if (fields == NULL) + return 0; + + if (_PyObject_LookupAttr(type, _Py_ID(_swappedbytes_), &tmp) < 0) { + return -1; + } + if (tmp) { + Py_DECREF(tmp); + big_endian = !PY_BIG_ENDIAN; + } + else { + big_endian = PY_BIG_ENDIAN; + } + + if (_PyObject_LookupAttr(type, _Py_ID(_pack_), &tmp) < 0) { + return -1; + } + if (tmp) { + pack = _PyLong_AsInt(tmp); + Py_DECREF(tmp); + if (pack < 0) { + if (!PyErr_Occurred() || + PyErr_ExceptionMatches(PyExc_TypeError) || + PyErr_ExceptionMatches(PyExc_OverflowError)) + { + PyErr_SetString(PyExc_ValueError, + "_pack_ must be a non-negative integer"); + } + return -1; + } + } + else { + /* Setting `_pack_ = 0` amounts to using the default alignment */ + pack = 0; + } + + len = PySequence_Size(fields); + if (len == -1) { + if (PyErr_ExceptionMatches(PyExc_TypeError)) { + PyErr_SetString(PyExc_TypeError, + "'_fields_' must be a sequence of pairs"); + } + return -1; + } + + stgdict = PyType_stgdict(type); + if (!stgdict) { + PyErr_SetString(PyExc_TypeError, + "ctypes state is not initialized"); + return -1; + } + /* If this structure/union is already marked final we cannot assign + _fields_ anymore. */ + + if (stgdict->flags & DICTFLAG_FINAL) {/* is final ? */ + PyErr_SetString(PyExc_AttributeError, + "_fields_ is final"); + return -1; + } + + if (stgdict->format) { + PyMem_Free(stgdict->format); + stgdict->format = NULL; + } + + if (stgdict->ffi_type_pointer.elements) + PyMem_Free(stgdict->ffi_type_pointer.elements); + + basedict = PyType_stgdict((PyObject *)((PyTypeObject *)type)->tp_base); + if (basedict) { + stgdict->flags |= (basedict->flags & + (TYPEFLAG_HASUNION | TYPEFLAG_HASBITFIELD)); + } + if (!isStruct) { + stgdict->flags |= TYPEFLAG_HASUNION; + } + if (basedict) { + size = offset = basedict->size; + align = basedict->align; + union_size = 0; + total_align = align ? align : 1; + stgdict->ffi_type_pointer.type = FFI_TYPE_STRUCT; + stgdict->ffi_type_pointer.elements = PyMem_New(ffi_type *, basedict->length + len + 1); + if (stgdict->ffi_type_pointer.elements == NULL) { + PyErr_NoMemory(); + return -1; + } + memset(stgdict->ffi_type_pointer.elements, 0, + sizeof(ffi_type *) * (basedict->length + len + 1)); + if (basedict->length > 0) { + memcpy(stgdict->ffi_type_pointer.elements, + basedict->ffi_type_pointer.elements, + sizeof(ffi_type *) * (basedict->length)); + } + ffi_ofs = basedict->length; + } else { + offset = 0; + size = 0; + align = 0; + union_size = 0; + total_align = 1; + stgdict->ffi_type_pointer.type = FFI_TYPE_STRUCT; + stgdict->ffi_type_pointer.elements = PyMem_New(ffi_type *, len + 1); + if (stgdict->ffi_type_pointer.elements == NULL) { + PyErr_NoMemory(); + return -1; + } + memset(stgdict->ffi_type_pointer.elements, 0, + sizeof(ffi_type *) * (len + 1)); + ffi_ofs = 0; + } + + assert(stgdict->format == NULL); + if (isStruct) { + stgdict->format = _ctypes_alloc_format_string(NULL, "T{"); + } else { + /* PEP3118 doesn't support union. Use 'B' for bytes. */ + stgdict->format = _ctypes_alloc_format_string(NULL, "B"); + } + if (stgdict->format == NULL) + return -1; + + for (i = 0; i < len; ++i) { + PyObject *name = NULL, *desc = NULL; + PyObject *pair = PySequence_GetItem(fields, i); + PyObject *prop; + StgDictObject *dict; + int bitsize = 0; + + if (!pair || !PyArg_ParseTuple(pair, "UO|i", &name, &desc, &bitsize)) { + PyErr_SetString(PyExc_TypeError, + "'_fields_' must be a sequence of (name, C type) pairs"); + Py_XDECREF(pair); + return -1; + } + if (PyCArrayTypeObject_Check(desc)) + arrays_seen = 1; + dict = PyType_stgdict(desc); + if (dict == NULL) { + Py_DECREF(pair); + PyErr_Format(PyExc_TypeError, + "second item in _fields_ tuple (index %zd) must be a C type", + i); + return -1; + } + stgdict->ffi_type_pointer.elements[ffi_ofs + i] = &dict->ffi_type_pointer; + if (dict->flags & (TYPEFLAG_ISPOINTER | TYPEFLAG_HASPOINTER)) + stgdict->flags |= TYPEFLAG_HASPOINTER; + stgdict->flags |= dict->flags & (TYPEFLAG_HASUNION | TYPEFLAG_HASBITFIELD); + dict->flags |= DICTFLAG_FINAL; /* mark field type final */ + if (PyTuple_Size(pair) == 3) { /* bits specified */ + stgdict->flags |= TYPEFLAG_HASBITFIELD; + switch(dict->ffi_type_pointer.type) { + case FFI_TYPE_UINT8: + case FFI_TYPE_UINT16: + case FFI_TYPE_UINT32: + case FFI_TYPE_SINT64: + case FFI_TYPE_UINT64: + break; + + case FFI_TYPE_SINT8: + case FFI_TYPE_SINT16: + case FFI_TYPE_SINT32: + if (dict->getfunc != _ctypes_get_fielddesc("c")->getfunc + && dict->getfunc != _ctypes_get_fielddesc("u")->getfunc + ) + break; + /* else fall through */ + default: + PyErr_Format(PyExc_TypeError, + "bit fields not allowed for type %s", + ((PyTypeObject *)desc)->tp_name); + Py_DECREF(pair); + return -1; + } + if (bitsize <= 0 || bitsize > dict->size * 8) { + PyErr_SetString(PyExc_ValueError, + "number of bits invalid for bit field"); + Py_DECREF(pair); + return -1; + } + } else + bitsize = 0; + + if (isStruct) { + const char *fieldfmt = dict->format ? dict->format : "B"; + const char *fieldname = PyUnicode_AsUTF8(name); + char *ptr; + Py_ssize_t len; + char *buf; + Py_ssize_t last_size = size; + Py_ssize_t padding; + + if (fieldname == NULL) + { + Py_DECREF(pair); + return -1; + } + + /* construct the field now, as `prop->offset` is `offset` with + corrected alignment */ + prop = PyCField_FromDesc(desc, i, + &field_size, bitsize, &bitofs, + &size, &offset, &align, + pack, big_endian); + if (prop == NULL) { + Py_DECREF(pair); + return -1; + } + + /* number of bytes between the end of the last field and the start + of this one */ + padding = ((CFieldObject *)prop)->offset - last_size; + + if (padding > 0) { + ptr = stgdict->format; + stgdict->format = _ctypes_alloc_format_padding(ptr, padding); + PyMem_Free(ptr); + if (stgdict->format == NULL) { + Py_DECREF(pair); + Py_DECREF(prop); + return -1; + } + } + + len = strlen(fieldname) + strlen(fieldfmt); + + buf = PyMem_Malloc(len + 2 + 1); + if (buf == NULL) { + Py_DECREF(pair); + Py_DECREF(prop); + PyErr_NoMemory(); + return -1; + } + sprintf(buf, "%s:%s:", fieldfmt, fieldname); + + ptr = stgdict->format; + if (dict->shape != NULL) { + stgdict->format = _ctypes_alloc_format_string_with_shape( + dict->ndim, dict->shape, stgdict->format, buf); + } else { + stgdict->format = _ctypes_alloc_format_string(stgdict->format, buf); + } + PyMem_Free(ptr); + PyMem_Free(buf); + + if (stgdict->format == NULL) { + Py_DECREF(pair); + Py_DECREF(prop); + return -1; + } + } else /* union */ { + size = 0; + offset = 0; + align = 0; + prop = PyCField_FromDesc(desc, i, + &field_size, bitsize, &bitofs, + &size, &offset, &align, + pack, big_endian); + if (prop == NULL) { + Py_DECREF(pair); + return -1; + } + union_size = max(size, union_size); + } + total_align = max(align, total_align); + + if (-1 == PyObject_SetAttr(type, name, prop)) { + Py_DECREF(prop); + Py_DECREF(pair); + return -1; + } + Py_DECREF(pair); + Py_DECREF(prop); + } + + if (!isStruct) { + size = union_size; + } + + /* Adjust the size according to the alignment requirements */ + aligned_size = ((size + total_align - 1) / total_align) * total_align; + + if (isStruct) { + char *ptr; + Py_ssize_t padding; + + /* Pad up to the full size of the struct */ + padding = aligned_size - size; + if (padding > 0) { + ptr = stgdict->format; + stgdict->format = _ctypes_alloc_format_padding(ptr, padding); + PyMem_Free(ptr); + if (stgdict->format == NULL) { + return -1; + } + } + + ptr = stgdict->format; + stgdict->format = _ctypes_alloc_format_string(stgdict->format, "}"); + PyMem_Free(ptr); + if (stgdict->format == NULL) + return -1; + } + + stgdict->ffi_type_pointer.alignment = Py_SAFE_DOWNCAST(total_align, + Py_ssize_t, + unsigned short); + stgdict->ffi_type_pointer.size = aligned_size; + + stgdict->size = aligned_size; + stgdict->align = total_align; + stgdict->length = ffi_ofs + len; + +/* + * The value of MAX_STRUCT_SIZE depends on the platform Python is running on. + */ +#if defined(__aarch64__) || defined(__arm__) || defined(_M_ARM64) +# define MAX_STRUCT_SIZE 32 +#elif defined(__powerpc64__) +# define MAX_STRUCT_SIZE 64 +#else +# define MAX_STRUCT_SIZE 16 +#endif + + if (arrays_seen && (size <= MAX_STRUCT_SIZE)) { + /* + * See bpo-22273 and gh-110190. Arrays are normally treated as + * pointers, which is fine when an array name is being passed as + * parameter, but not when passing structures by value that contain + * arrays. + * Small structures passed by value are passed in registers, and in + * order to do this, libffi needs to know the true type of the array + * members of structs. Treating them as pointers breaks things. + * + * Small structures have different sizes depending on the platform + * where Python is running on: + * + * * x86-64: 16 bytes or less + * * Arm platforms (both 32 and 64 bit): 32 bytes or less + * * PowerPC 64 Little Endian: 64 bytes or less + * + * In that case, there can't be more than 16, 32 or 64 elements after + * unrolling arrays, as we (will) disallow bitfields. + * So we can collect the true ffi_type values in a fixed-size local + * array on the stack and, if any arrays were seen, replace the + * ffi_type_pointer.elements with a more accurate set, to allow + * libffi to marshal them into registers correctly. + * It means one more loop over the fields, but if we got here, + * the structure is small, so there aren't too many of those. + * + * Although the passing in registers is specific to the above + * platforms, the array-in-struct vs. pointer problem is general. + * But we restrict the type transformation to small structs + * nonetheless. + * + * Note that although a union may be small in terms of memory usage, it + * could contain many overlapping declarations of arrays, e.g. + * + * union { + * unsigned int_8 foo [16]; + * unsigned uint_8 bar [16]; + * unsigned int_16 baz[8]; + * unsigned uint_16 bozz[8]; + * unsigned int_32 fizz[4]; + * unsigned uint_32 buzz[4]; + * } + * + * which is still only 16 bytes in size. We need to convert this into + * the following equivalent for libffi: + * + * union { + * struct { int_8 e1; int_8 e2; ... int_8 e_16; } f1; + * struct { uint_8 e1; uint_8 e2; ... uint_8 e_16; } f2; + * struct { int_16 e1; int_16 e2; ... int_16 e_8; } f3; + * struct { uint_16 e1; uint_16 e2; ... uint_16 e_8; } f4; + * struct { int_32 e1; int_32 e2; ... int_32 e_4; } f5; + * struct { uint_32 e1; uint_32 e2; ... uint_32 e_4; } f6; + * } + * + * The same principle applies for a struct 32 or 64 bytes in size. + * + * So the struct/union needs setting up as follows: all non-array + * elements copied across as is, and all array elements replaced with + * an equivalent struct which has as many fields as the array has + * elements, plus one NULL pointer. + */ + + Py_ssize_t num_ffi_type_pointers = 0; /* for the dummy fields */ + Py_ssize_t num_ffi_types = 0; /* for the dummy structures */ + size_t alloc_size; /* total bytes to allocate */ + void *type_block; /* to hold all the type information needed */ + ffi_type **element_types; /* of this struct/union */ + ffi_type **dummy_types; /* of the dummy struct elements */ + ffi_type *structs; /* point to struct aliases of arrays */ + Py_ssize_t element_index; /* index into element_types for this */ + Py_ssize_t dummy_index = 0; /* index into dummy field pointers */ + Py_ssize_t struct_index = 0; /* index into dummy structs */ + + /* first pass to see how much memory to allocate */ + for (i = 0; i < len; ++i) { + PyObject *name, *desc; + PyObject *pair = PySequence_GetItem(fields, i); + StgDictObject *dict; + int bitsize = 0; + + if (pair == NULL) { + return -1; + } + if (!PyArg_ParseTuple(pair, "UO|i", &name, &desc, &bitsize)) { + PyErr_SetString(PyExc_TypeError, + "'_fields_' must be a sequence of (name, C type) pairs"); + Py_DECREF(pair); + return -1; + } + dict = PyType_stgdict(desc); + if (dict == NULL) { + Py_DECREF(pair); + PyErr_Format(PyExc_TypeError, + "second item in _fields_ tuple (index %zd) must be a C type", + i); + return -1; + } + if (!PyCArrayTypeObject_Check(desc)) { + /* Not an array. Just need an ffi_type pointer. */ + num_ffi_type_pointers++; + } + else { + /* It's an array. */ + Py_ssize_t length = dict->length; + StgDictObject *edict; + + edict = PyType_stgdict(dict->proto); + if (edict == NULL) { + Py_DECREF(pair); + PyErr_Format(PyExc_TypeError, + "second item in _fields_ tuple (index %zd) must be a C type", + i); + return -1; + } + /* + * We need one extra ffi_type to hold the struct, and one + * ffi_type pointer per array element + one for a NULL to + * mark the end. + */ + num_ffi_types++; + num_ffi_type_pointers += length + 1; + } + Py_DECREF(pair); + } + + /* + * At this point, we know we need storage for some ffi_types and some + * ffi_type pointers. We'll allocate these in one block. + * There are three sub-blocks of information: the ffi_type pointers to + * this structure/union's elements, the ffi_type_pointers to the + * dummy fields standing in for array elements, and the + * ffi_types representing the dummy structures. + */ + alloc_size = (ffi_ofs + 1 + len + num_ffi_type_pointers) * sizeof(ffi_type *) + + num_ffi_types * sizeof(ffi_type); + type_block = PyMem_Malloc(alloc_size); + + if (type_block == NULL) { + PyErr_NoMemory(); + return -1; + } + /* + * the first block takes up ffi_ofs + len + 1 which is the pointers * + * for this struct/union. The second block takes up + * num_ffi_type_pointers, so the sum of these is ffi_ofs + len + 1 + + * num_ffi_type_pointers as allocated above. The last bit is the + * num_ffi_types structs. + */ + element_types = (ffi_type **) type_block; + dummy_types = &element_types[ffi_ofs + len + 1]; + structs = (ffi_type *) &dummy_types[num_ffi_type_pointers]; + + if (num_ffi_types > 0) { + memset(structs, 0, num_ffi_types * sizeof(ffi_type)); + } + if (ffi_ofs && (basedict != NULL)) { + memcpy(element_types, + basedict->ffi_type_pointer.elements, + ffi_ofs * sizeof(ffi_type *)); + } + element_index = ffi_ofs; + + /* second pass to actually set the type pointers */ + for (i = 0; i < len; ++i) { + PyObject *name, *desc; + PyObject *pair = PySequence_GetItem(fields, i); + StgDictObject *dict; + int bitsize = 0; + + if (pair == NULL) { + PyMem_Free(type_block); + return -1; + } + /* In theory, we made this call in the first pass, so it *shouldn't* + * fail. However, you never know, and the code above might change + * later - keeping the check in here is a tad defensive but it + * will affect program size only slightly and performance hardly at + * all. + */ + if (!PyArg_ParseTuple(pair, "UO|i", &name, &desc, &bitsize)) { + PyErr_SetString(PyExc_TypeError, + "'_fields_' must be a sequence of (name, C type) pairs"); + Py_DECREF(pair); + PyMem_Free(type_block); + return -1; + } + dict = PyType_stgdict(desc); + /* Possibly this check could be avoided, but see above comment. */ + if (dict == NULL) { + Py_DECREF(pair); + PyMem_Free(type_block); + PyErr_Format(PyExc_TypeError, + "second item in _fields_ tuple (index %zd) must be a C type", + i); + return -1; + } + assert(element_index < (ffi_ofs + len)); /* will be used below */ + if (!PyCArrayTypeObject_Check(desc)) { + /* Not an array. Just copy over the element ffi_type. */ + element_types[element_index++] = &dict->ffi_type_pointer; + } + else { + Py_ssize_t length = dict->length; + StgDictObject *edict; + + edict = PyType_stgdict(dict->proto); + if (edict == NULL) { + Py_DECREF(pair); + PyMem_Free(type_block); + PyErr_Format(PyExc_TypeError, + "second item in _fields_ tuple (index %zd) must be a C type", + i); + return -1; + } + element_types[element_index++] = &structs[struct_index]; + structs[struct_index].size = length * edict->ffi_type_pointer.size; + structs[struct_index].alignment = edict->ffi_type_pointer.alignment; + structs[struct_index].type = FFI_TYPE_STRUCT; + structs[struct_index].elements = &dummy_types[dummy_index]; + ++struct_index; + /* Copy over the element's type, length times. */ + while (length > 0) { + assert(dummy_index < (num_ffi_type_pointers)); + dummy_types[dummy_index++] = &edict->ffi_type_pointer; + length--; + } + assert(dummy_index < (num_ffi_type_pointers)); + dummy_types[dummy_index++] = NULL; + } + Py_DECREF(pair); + } + + element_types[element_index] = NULL; + /* + * Replace the old elements with the new, taking into account + * base class elements where necessary. + */ + assert(stgdict->ffi_type_pointer.elements); + PyMem_Free(stgdict->ffi_type_pointer.elements); + stgdict->ffi_type_pointer.elements = element_types; + } + + /* We did check that this flag was NOT set above, it must not + have been set until now. */ + if (stgdict->flags & DICTFLAG_FINAL) { + PyErr_SetString(PyExc_AttributeError, + "Structure or union cannot contain itself"); + return -1; + } + stgdict->flags |= DICTFLAG_FINAL; + + return MakeAnonFields(type); +} diff --git a/graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.h b/graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.h deleted file mode 100644 index 8e4646adc9..0000000000 --- a/graalpython/com.oracle.graal.python.cext/modules/_ctypes_test.h +++ /dev/null @@ -1,6 +0,0 @@ -/* Copyright (c) 2021, Oracle and/or its affiliates. - * Copyright (C) 1996-2020 Python Software Foundation - * - * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 - */ -extern int _testfunc_i_bhilfd(char b, short h, int i, long l, float f, double d); diff --git a/graalpython/com.oracle.graal.python.cext/modules/clinic/sha3module.c.h b/graalpython/com.oracle.graal.python.cext/modules/clinic/sha3module.c.h index 14b520f34a..ff6c4e236f 100644 --- a/graalpython/com.oracle.graal.python.cext/modules/clinic/sha3module.c.h +++ b/graalpython/com.oracle.graal.python.cext/modules/clinic/sha3module.c.h @@ -46,7 +46,8 @@ py_sha3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) #endif // !Py_BUILD_CORE static const char * const _keywords[] = {"", "usedforsecurity", NULL}; - static _PyArg_Parser _parser = { + // GraalPy change: was 'static' + _PyArg_Parser _parser = { .keywords = _keywords, .fname = "sha3_224", .kwtuple = KWTUPLE, diff --git a/graalpython/com.oracle.graal.python.cext/src/abstract.c b/graalpython/com.oracle.graal.python.cext/src/abstract.c index 09e3fa48d1..c7aaa5b41b 100644 --- a/graalpython/com.oracle.graal.python.cext/src/abstract.c +++ b/graalpython/com.oracle.graal.python.cext/src/abstract.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -11,8 +11,8 @@ #if 0 // GraalPy change #include "pycore_call.h" // _PyObject_CallNoArgs() #include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate() -#include "pycore_object.h" // _Py_CheckSlotResult() #endif // GraalPy change +#include "pycore_object.h" // _Py_CheckSlotResult() #include "pycore_long.h" // _Py_IsNegative #include "pycore_pyerrors.h" // _PyErr_Occurred() #include "pycore_pystate.h" // _PyThreadState_GET() @@ -1453,8 +1453,6 @@ PyIndex_Check(PyObject *obj) return _PyIndex_Check(obj); } - -#if 0 // GraalPy change /* Return a Python int from the object item. Can return an instance of int subclass. Raise TypeError if the result is not an int @@ -1470,6 +1468,12 @@ _PyNumber_Index(PyObject *item) if (PyLong_Check(item)) { return Py_NewRef(item); } + + // GraalPy change: upcall for managed objects + if (points_to_py_handle_space(item)) { + return GraalPyPrivate_PyNumber_Index(item); + } + if (!_PyIndex_Check(item)) { PyErr_Format(PyExc_TypeError, "'%.200s' object cannot be interpreted " @@ -1511,11 +1515,14 @@ PyNumber_Index(PyObject *item) { PyObject *result = _PyNumber_Index(item); if (result != NULL && !PyLong_CheckExact(result)) { - Py_SETREF(result, _PyLong_Copy((PyLongObject *)result)); + if (points_to_py_handle_space(result)) { + Py_SETREF(result, GraalPyPrivate_PyNumber_IndexCopy(result)); + } else { + Py_SETREF(result, _PyLong_Copy((PyLongObject *)result)); + } } return result; } -#endif // GraalPy change /* Return an error on Overflow only if err is not NULL*/ @@ -1571,14 +1578,15 @@ PyNumber_AsSsize_t(PyObject *item, PyObject *err) } -#if 0 // GraalPy change PyObject * PyNumber_Long(PyObject *o) { +#if 0 // GraalPy change PyObject *result; PyNumberMethods *m; PyObject *trunc_func; Py_buffer view; +#endif // GraalPy change if (o == NULL) { return null_error(); @@ -1587,6 +1595,12 @@ PyNumber_Long(PyObject *o) if (PyLong_CheckExact(o)) { return Py_NewRef(o); } + + /* GraalPy change: The above case already handles boxed long values. Hence, + those may not reach this point. */ + assert (!points_to_py_int_handle(o)); + return GraalPyPrivate_PyNumber_Long(o); +#if 0 // GraalPy change m = Py_TYPE(o)->tp_as_number; if (m && m->nb_int) { /* This should include subclasses of int */ /* Convert using the nb_int slot, which should return something @@ -1685,6 +1699,7 @@ PyNumber_Long(PyObject *o) return type_error("int() argument must be a string, a bytes-like object " "or a real number, not '%.200s'", o); +#endif // GraalPy change } PyObject * @@ -1698,6 +1713,19 @@ PyNumber_Float(PyObject *o) return Py_NewRef(o); } + // GraalPy change + if (points_to_py_float_handle(o)) { + assert(Py_REFCNT(o) == _Py_IMMORTAL_REFCNT); + return o; + } + if (points_to_py_int_handle(o)) { + assert(Py_REFCNT(o) == _Py_IMMORTAL_REFCNT); + return PyFloat_FromDouble(pointer_to_int64(o)); + } + + return GraalPyPrivate_PyNumber_Float(o); + +#if 0 // GraalPy change PyNumberMethods *m = Py_TYPE(o)->tp_as_number; if (m && m->nb_float) { /* This should include subclasses of float */ PyObject *res = m->nb_float(o); @@ -1745,9 +1773,11 @@ PyNumber_Float(PyObject *o) return PyFloat_FromDouble(PyFloat_AS_DOUBLE(o)); } return PyFloat_FromString(o); +#endif // GraalPy change } +#if 0 // GraalPy change PyObject * PyNumber_ToBase(PyObject *n, int base) { @@ -2857,10 +2887,15 @@ _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls) return recursive_issubclass(derived, cls); } - +#endif // GraalPy change PyObject * PyObject_GetIter(PyObject *o) { + // GraalPy change: upcall for managed objects + if (points_to_py_handle_space(o)) { + return GraalPyPrivate_Object_GetIter(o); + } + PyTypeObject *t = Py_TYPE(o); getiterfunc f; @@ -2882,7 +2917,7 @@ PyObject_GetIter(PyObject *o) return res; } } - +#if 0 // GraalPy change PyObject * PyObject_GetAIter(PyObject *o) { PyTypeObject *t = Py_TYPE(o); @@ -2901,7 +2936,7 @@ PyObject_GetAIter(PyObject *o) { } return it; } - +#endif // GraalPy change int PyIter_Check(PyObject *obj) { @@ -2909,7 +2944,7 @@ PyIter_Check(PyObject *obj) return (tp->tp_iternext != NULL && tp->tp_iternext != &_PyObject_NextNotImplemented); } - +#if 0 // GraalPy change int PyAIter_Check(PyObject *obj) { diff --git a/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c b/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c index b989a18841..e23eeb0c94 100644 --- a/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -51,7 +51,7 @@ _getbytevalue(PyObject* arg, int *value) } #endif // GraalPy change -int // GraalPy change: not static +Py_LOCAL_SYMBOL int // GraalPy change: hidden for capi.c bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags) { void *ptr; @@ -68,7 +68,7 @@ bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags) return 0; } -void // GraalPy change: not static +Py_LOCAL_SYMBOL void // GraalPy change: hidden for capi.c bytearray_releasebuffer(PyByteArrayObject *obj, Py_buffer *view) { // GraalPy change diff --git a/graalpython/com.oracle.graal.python.cext/src/bytesobject.c b/graalpython/com.oracle.graal.python.cext/src/bytesobject.c index cb989fad50..dade5bdc54 100644 --- a/graalpython/com.oracle.graal.python.cext/src/bytesobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/bytesobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -9,6 +9,7 @@ #include "capi.h" // GraalPy change #include "Python.h" +#include "pycore_global_objects.h" // _Py_SINGLETON() // GraalPy change #if 0 // GraalPy change #include "pycore_abstract.h" // _PyIndex_Check() #include "pycore_bytesobject.h" // _PyBytes_Find(), _PyBytes_Repeat() @@ -25,6 +26,29 @@ #include +// Return a strong reference to the empty bytes string singleton. +static inline PyObject* bytes_new_empty(void) +{ + return Py_NewRef(&_Py_SINGLETON(bytes_empty)); +} + +// Return a strong reference to a cached one-byte bytes string singleton. +static inline PyObject* bytes_new_character(unsigned char ch) +{ + return Py_NewRef(PyThreadState_Get()->singletons.bytes_characters[ch]); +} + +static inline int bytes_is_character_singleton(PyObject *op) +{ + PyObject **characters = PyThreadState_Get()->singletons.bytes_characters; + for (int i = 0; i < 256; i++) { + if (op == characters[i]) { + return 1; + } + } + return 0; +} + /*[clinic input] class bytes "PyBytesObject *" "&PyBytes_Type" [clinic start generated code]*/ @@ -133,6 +157,12 @@ PyBytes_FromStringAndSize(const char *str, Py_ssize_t size) "Negative size passed to PyBytes_FromStringAndSize"); return NULL; } + if (size == 0) { + return bytes_new_empty(); + } + if (size == 1 && str != NULL) { + return bytes_new_character((unsigned char)*str); + } if (str != NULL) { return GraalPyPrivate_Bytes_FromStringAndSize(str, size); } @@ -143,10 +173,15 @@ PyObject * PyBytes_FromString(const char *str) { // GraalPy change: different implementation - if (str != NULL) { - return GraalPyPrivate_Bytes_FromStringAndSize(str, strlen(str)); - } - return GraalPyPrivate_Bytes_EmptyWithCapacity(0); + assert(str != NULL); + Py_ssize_t size = strlen(str); + if (size == 0) { + return bytes_new_empty(); + } + if (size == 1) { + return bytes_new_character((unsigned char)*str); + } + return GraalPyPrivate_Bytes_FromStringAndSize(str, size); } PyObject * @@ -1587,7 +1622,7 @@ bytes_subscript(PyBytesObject* self, PyObject* item) } #endif // GraalPy change -int // GraalPy change: not static +Py_LOCAL_SYMBOL int // GraalPy change: hidden for capi.c bytes_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags) { // GraalPy change: avoid direct struct access @@ -2820,8 +2855,8 @@ _Py_COMP_DIAG_POP } #endif // GraalPy change -// GraalPy change: export for downcall, rename, use C array instead of bytes -PyAPI_FUNC(PyObject *) +// GraalPy change: helper-table entry for downcall, rename, use C array instead of bytes +GraalPy_CAPI_HELPER_SYMBOL PyObject * GraalPyPrivate_Bytes_SubtypeNew(PyTypeObject *type, int8_t* contents, Py_ssize_t n) { // GraalPy change: different implementation PyObject* bytes = type->tp_alloc(type, n); @@ -2927,6 +2962,32 @@ int _PyBytes_Resize(PyObject **pv, Py_ssize_t newsize) { // GraalPy change: different implementation + PyObject *v = *pv; + if (!PyBytes_Check(v) || newsize < 0) { + *pv = NULL; + Py_DECREF(v); + PyErr_BadInternalCall(); + return -1; + } + if (Py_SIZE(v) == newsize) { + return 0; + } + if (Py_SIZE(v) == 0) { + *pv = GraalPyPrivate_Bytes_EmptyWithCapacity(newsize); + Py_DECREF(v); + return *pv == NULL ? -1 : 0; + } + if (bytes_is_character_singleton(v)) { + *pv = NULL; + Py_DECREF(v); + PyErr_BadInternalCall(); + return -1; + } + if (newsize == 0) { + *pv = bytes_new_empty(); + Py_DECREF(v); + return 0; + } return GraalPyPrivate_Bytes_Resize(*pv, newsize); } @@ -3393,4 +3454,3 @@ _PyBytes_Repeat(char* dest, Py_ssize_t len_dest, } } #endif // GraalPy change - diff --git a/graalpython/com.oracle.graal.python.cext/src/call.c b/graalpython/com.oracle.graal.python.cext/src/call.c index 5aac823ab5..67af8e400b 100644 --- a/graalpython/com.oracle.graal.python.cext/src/call.c +++ b/graalpython/com.oracle.graal.python.cext/src/call.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2023, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2023, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -833,6 +833,7 @@ _PyObject_CallMethodId_SizeT(PyObject *obj, _Py_Identifier *name, Py_DECREF(callable); return retval; } +#endif // GraalPy change /* --- Call with "..." arguments ---------------------------------- */ @@ -898,7 +899,59 @@ object_vacall(PyThreadState *tstate, PyObject *base, } return result; } -#endif // GraalPy change + +static PyObject * +method_vacall(PyObject *receiver, PyObject *method_name, va_list vargs) +{ + PyObject *small_stack[_PY_FASTCALL_SMALL_STACK]; + PyObject **stack; + Py_ssize_t nargs; + PyObject *result; + Py_ssize_t i; + va_list countva; + + /* Count the number of arguments */ + va_copy(countva, vargs); + nargs = 0; + while (1) { + PyObject *arg = va_arg(countva, PyObject *); + if (arg == NULL) { + break; + } + nargs++; + } + va_end(countva); + + /* Copy arguments */ + if (nargs <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) { + stack = small_stack; + } + else { + stack = PyMem_Malloc(nargs * sizeof(stack[0])); + if (stack == NULL) { + PyErr_NoMemory(); + return NULL; + } + } + + i = 0; + for (; i < nargs; ++i) { + stack[i] = va_arg(vargs, PyObject *); + } + +#ifdef Py_STATS + if (PyFunction_Check(callable)) { + EVAL_CALL_STAT_INC(EVAL_CALL_API); + } +#endif + /* Call the function */ + result = GraalPyPrivate_Object_CallMethodObjArgs(receiver, method_name, stack, nargs); + + if (stack != small_stack) { + PyMem_Free(stack); + } + return result; +} PyObject * @@ -940,12 +993,34 @@ PyObject_VectorcallMethod(PyObject *name, PyObject *const *args, PyObject * PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ...) { - // GraalPy change: different implementation + PyThreadState *tstate = _PyThreadState_GET(); + if (obj == NULL || name == NULL) { + return null_error(tstate); + } + + /* GraalPy change: If the receiver is a managed object, we only collect + the va_list arguments in native and do everything else in managed. */ + if (points_to_py_handle_space(obj)) { + va_list vargs; + va_start(vargs, name); + PyObject *result = method_vacall(obj, name, vargs); + va_end(vargs); + return result; + } + + PyObject *callable = NULL; + int is_method = _PyObject_GetMethod(obj, name, &callable); + if (callable == NULL) { + return NULL; + } + obj = is_method ? obj : NULL; + va_list vargs; va_start(vargs, name); - // the arguments are given as a variable list followed by NULL - PyObject *result = GraalPyPrivate_Object_CallMethodObjArgs(obj, name, &vargs); + PyObject *result = object_vacall(tstate, obj, callable, vargs); va_end(vargs); + + Py_DECREF(callable); return result; } @@ -953,12 +1028,39 @@ PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ...) PyObject * _PyObject_CallMethodIdObjArgs(PyObject *obj, _Py_Identifier *name, ...) { - // GraalPy change: different implementation + PyThreadState *tstate = _PyThreadState_GET(); + if (obj == NULL || name == NULL) { + return null_error(tstate); + } + + PyObject *oname = _PyUnicode_FromId(name); /* borrowed */ + if (!oname) { + return NULL; + } + + /* GraalPy change: If the receiver is a managed object, we only collect + the va_list arguments in native and do everything else in managed. */ + if (points_to_py_handle_space(obj)) { + va_list vargs; + va_start(vargs, name); + PyObject *result = method_vacall(obj, oname, vargs); + va_end(vargs); + return result; + } + + PyObject *callable = NULL; + int is_method = _PyObject_GetMethod(obj, oname, &callable); + if (callable == NULL) { + return NULL; + } + obj = is_method ? obj : NULL; + va_list vargs; va_start(vargs, name); - // the arguments are given as a variable list followed by NULL - PyObject *result = GraalPyPrivate_Object_CallMethodObjArgs(obj, _PyUnicode_FromId(name), &vargs); + PyObject *result = object_vacall(tstate, obj, callable, vargs); va_end(vargs); + + Py_DECREF(callable); return result; } @@ -966,12 +1068,14 @@ _PyObject_CallMethodIdObjArgs(PyObject *obj, _Py_Identifier *name, ...) PyObject * PyObject_CallFunctionObjArgs(PyObject *callable, ...) { - // GraalPy change: different implementation + PyThreadState *tstate = _PyThreadState_GET(); va_list vargs; + PyObject *result; + va_start(vargs, callable); - // the arguments are given as a variable list followed by NULL - PyObject *result = GraalPyPrivate_Object_CallFunctionObjArgs(callable, &vargs); + result = object_vacall(tstate, NULL, callable, vargs); va_end(vargs); + return result; } diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.c b/graalpython/com.oracle.graal.python.cext/src/capi.c index cb2bd845be..f42088521c 100644 --- a/graalpython/com.oracle.graal.python.cext/src/capi.c +++ b/graalpython/com.oracle.graal.python.cext/src/capi.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -45,6 +45,20 @@ #include "pycore_gc.h" // _PyGC_InitState +#define GRAALPY_ENABLE_TESTING_CAPI +#include "graalpy/testcapi.h" +#undef GRAALPY_ENABLE_TESTING_CAPI + +Py_LOCAL_SYMBOL void +GraalPyPrivate_LogImpl(int level, const char *format, va_list args) +{ + char buffer[1024]; + int written = PyOS_vsnprintf(buffer, sizeof(buffer), format, args); + if (written >= 0) { + GraalPyPrivate_LogString(level, buffer); + } +} + typedef struct arrayobject { PyObject_VAR_HEAD char *ob_item; @@ -98,7 +112,45 @@ typedef struct { } PyPickleBufferObject; // defined in 'unicodeobject.c' -void unicode_dealloc(PyObject *unicode); +Py_LOCAL_SYMBOL void unicode_dealloc(PyObject *unicode); + +Py_LOCAL_SYMBOL NO_INLINE void +graalpy_dealloc_stack_grow(PyThreadState *tstate) +{ + size_t old_capacity; + size_t new_capacity; + + assert(tstate != NULL); + + old_capacity = (size_t)tstate->graalpy_deallocating.capacity; + new_capacity = old_capacity > 0 ? old_capacity * 2 : 3; + if (new_capacity <= old_capacity || new_capacity > INT_MAX) { + Py_FatalError("GraalPy deallocating stack capacity overflow"); + } + + if (GraalPyPrivate_DeallocStack_Grow(tstate, new_capacity) != 0) { + Py_FatalError("out of memory while growing GraalPy deallocating stack"); + } +} + +Py_LOCAL_SYMBOL void +graalpy_dealloc_stack_push(PyThreadState *tstate, PyObject *op) +{ + assert(tstate != NULL); + if (UNLIKELY(tstate->graalpy_deallocating.len >= tstate->graalpy_deallocating.capacity)) { + graalpy_dealloc_stack_grow(tstate); + } + tstate->graalpy_deallocating.items[tstate->graalpy_deallocating.len++] = op; +} + +Py_LOCAL_SYMBOL void +graalpy_dealloc_stack_pop(PyThreadState *tstate, PyObject *op) +{ + assert(tstate != NULL); + assert(tstate->graalpy_deallocating.len > 0); + assert(tstate->graalpy_deallocating.items[tstate->graalpy_deallocating.len - 1] == op); + tstate->graalpy_deallocating.items[--tstate->graalpy_deallocating.len] = NULL; +} static void object_dealloc(PyObject *self) { Py_TYPE(self)->tp_free(self); @@ -117,7 +169,6 @@ static void capsule_dealloc(PyObject *o) { PyAPI_DATA(PyTypeObject) _PyExc_BaseException; PyAPI_DATA(PyTypeObject) _PyExc_StopIteration; -PyAPI_DATA(PyTypeObject) mmap_object_type; // used for sizeof(...) typedef struct { @@ -142,8 +193,8 @@ typedef struct { int strict; } zipobject; -#define PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__, __ALLOC__, __DEALLOC__, __FREE__, __VCALL_OFFSET__) \ -PyTypeObject GLOBAL_NAME = {\ +#define PY_TRUFFLE_TYPE_GENERIC_WITH_STORAGE(STORAGE, GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__, __ALLOC__, __DEALLOC__, __FREE__, __VCALL_OFFSET__) \ +STORAGE PyTypeObject GLOBAL_NAME = {\ PyVarObject_HEAD_INIT((__SUPER_TYPE__), 0)\ __TYPE_NAME__, /* tp_name */\ (__SIZE__), /* tp_basicsize */\ @@ -186,18 +237,27 @@ PyTypeObject GLOBAL_NAME = {\ 0, /* tp_is_gc */\ }; +#define PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__, __ALLOC__, __DEALLOC__, __FREE__, __VCALL_OFFSET__) \ +PY_TRUFFLE_TYPE_GENERIC_WITH_STORAGE(, GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__, __ALLOC__, __DEALLOC__, __FREE__, __VCALL_OFFSET__) + +#undef PY_TRUFFLE_TYPE_LOCAL +#define PY_TRUFFLE_TYPE_LOCAL(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__) \ +PY_TRUFFLE_TYPE_GENERIC_WITH_STORAGE(static, GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, 0, 0, 0, 0, 0) + #define PY_TRUFFLE_TYPE_EXTERN(GLOBAL_NAME, NAME) #define PY_TRUFFLE_TYPE_UNIMPLEMENTED(GLOBAL_NAME) PyTypeObject GLOBAL_NAME; PY_TYPE_OBJECTS #undef PY_TRUFFLE_TYPE_GENERIC +#undef PY_TRUFFLE_TYPE_GENERIC_WITH_STORAGE +#undef PY_TRUFFLE_TYPE_LOCAL #undef PY_TRUFFLE_TYPE_EXTERN #undef PY_TRUFFLE_TYPE_UNIMPLEMENTED -#define PUBLIC_BUILTIN(NAME, RET, ...) RET (*GraalPyPrivate_Upcall_##NAME)(__VA_ARGS__); -#define PRIVATE_BUILTIN(NAME, RET, ...) RET (*NAME)(__VA_ARGS__); +#define PUBLIC_BUILTIN(NAME, RET, ...) Py_LOCAL_SYMBOL RET (*GraalPyPrivate_Upcall_##NAME)(__VA_ARGS__); +#define PRIVATE_BUILTIN(NAME, RET, ...) Py_LOCAL_SYMBOL RET (*NAME)(__VA_ARGS__); CAPI_BUILTINS #undef PUBLIC_BUILTIN #undef PRIVATE_BUILTIN @@ -211,18 +271,20 @@ CAPI_BUILTINS #undef PRIVATE_BUILTIN } -uint32_t Py_Truffle_Options; +Py_LOCAL_SYMBOL uint32_t Py_Truffle_Options; #undef bool static void initialize_builtin_types_and_structs() { clock_t t = clock(); - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, "initialize_builtin_types_and_structs..."); + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "initialize_builtin_types_and_structs..."); static int64_t builtin_types[] = { #define PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, a, b, c, d, e, f, g) &GLOBAL_NAME, __TYPE_NAME__, +#define PY_TRUFFLE_TYPE_LOCAL(GLOBAL_NAME, __TYPE_NAME__, a, b) &GLOBAL_NAME, __TYPE_NAME__, #define PY_TRUFFLE_TYPE_EXTERN(GLOBAL_NAME, __TYPE_NAME__) &GLOBAL_NAME, __TYPE_NAME__, #define PY_TRUFFLE_TYPE_UNIMPLEMENTED(GLOBAL_NAME) // empty PY_TYPE_OBJECTS #undef PY_TRUFFLE_TYPE_GENERIC +#undef PY_TRUFFLE_TYPE_LOCAL #undef PY_TRUFFLE_TYPE_EXTERN #undef PY_TRUFFLE_TYPE_UNIMPLEMENTED NULL, NULL @@ -233,10 +295,10 @@ static void initialize_builtin_types_and_structs() { // fix up for circular dependency: PyType_Type.tp_base = &PyBaseObject_Type; - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, "initialize_builtin_types_and_structs: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "initialize_builtin_types_and_structs: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); } -int mmap_getbuffer(PyObject *self, Py_buffer *view, int flags) { +static int mmap_getbuffer(PyObject *self, Py_buffer *view, int flags) { // TODO(fa) readonly flag char* data = GraalPyPrivate_GetMMapData(self); if (!data) { @@ -245,8 +307,8 @@ int mmap_getbuffer(PyObject *self, Py_buffer *view, int flags) { return PyBuffer_FillInfo(view, (PyObject*)self, data, PyObject_Size((PyObject *)self), 0, flags); } -PyAPI_FUNC(void) GraalPyPrivate_MMap_InitBufferProtocol(PyObject* mmap_type) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, "GraalPyPrivate_MMap_InitBufferProtocol"); +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_MMap_InitBufferProtocol(PyObject* mmap_type) { + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "GraalPyPrivate_MMap_InitBufferProtocol"); assert(PyType_Check(mmap_type)); static PyBufferProcs mmap_as_buffer = { @@ -257,23 +319,6 @@ PyAPI_FUNC(void) GraalPyPrivate_MMap_InitBufferProtocol(PyObject* mmap_type) { ((PyTypeObject*) mmap_type)->tp_as_buffer = &mmap_as_buffer; } -static int cdata_getbuffer(PyObject* type, Py_buffer* view, int flags) { - return GraalPyPrivate_CData_NewGetBuffer(type, view, flags); -} - -static void cdata_releasebuffer(PyObject* obj, Py_buffer* view) { - GraalPyPrivate_CData_ReleaseBuffer(obj, view); -} - -PyAPI_FUNC(void) GraalPyPrivate_CData_InitBufferProtocol(PyObject* type) { - static PyBufferProcs cdata_as_buffer = { - cdata_getbuffer, - cdata_releasebuffer, - }; - GraalPyPrivate_Type_SetBufferProcs(((PyTypeObject*) type), &cdata_as_buffer); - ((PyTypeObject*) type)->tp_as_buffer = &cdata_as_buffer; -} - struct _longobject* _Py_FalseStructReference; struct _longobject* _Py_TrueStructReference; PyObject* _Py_EllipsisObjectReference; @@ -289,26 +334,32 @@ PyObject* _Py_NotImplementedStructReference; */ THREAD_LOCAL PyThreadState *tstate_current = NULL; -static void initialize_globals() { - // store the thread state into a thread local variable - tstate_current = GraalPyPrivate_ThreadState_Get(&tstate_current); +GraalPy_CAPI_HELPER_SYMBOL PyThreadState **GraalPyPrivate_InitThreadStateCurrent(PyThreadState *tstate) { + tstate_current = tstate; + graalpy_initialize_thread_state_singletons(tstate); + return &tstate_current; +} + +static void initialize_globals(PyThreadState *tstate) { + GraalPyPrivate_InitThreadStateCurrent(tstate); _Py_NoneStructReference = GraalPyPrivate_None(); _Py_NotImplementedStructReference = GraalPyPrivate_NotImplemented(); _Py_EllipsisObjectReference = GraalPyPrivate_Ellipsis(); _Py_TrueStructReference = (struct _longobject*)GraalPyPrivate_True(); _Py_FalseStructReference = (struct _longobject*)GraalPyPrivate_False(); + graalpy_initialize_thread_state_singletons(tstate); } /* internal functions to avoid unnecessary managed <-> native conversions */ /* BYTES, BYTEARRAY */ -int bytes_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags); -int bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags); -void bytearray_releasebuffer(PyByteArrayObject *obj, Py_buffer *view); +Py_LOCAL_SYMBOL int bytes_buffer_getbuffer(PyBytesObject *self, Py_buffer *view, int flags); +Py_LOCAL_SYMBOL int bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags); +Py_LOCAL_SYMBOL void bytearray_releasebuffer(PyByteArrayObject *obj, Py_buffer *view); /* MEMORYVIEW */ -int memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags); -void memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view); +Py_LOCAL_SYMBOL int memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags); +Py_LOCAL_SYMBOL void memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view); /* PICKLEBUFFER */ static int @@ -366,75 +417,32 @@ static void initialize_gc_types_related_slots() { int is_builtin_type(PyTypeObject *tp) { #define PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, a, b, c, d, e, f, g) (tp == &GLOBAL_NAME) || +#define PY_TRUFFLE_TYPE_LOCAL(GLOBAL_NAME, __TYPE_NAME__, a, b) (tp == &GLOBAL_NAME) || #define PY_TRUFFLE_TYPE_EXTERN(GLOBAL_NAME, __TYPE_NAME__) PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, 0, 0, 0, 0, 0, 0, 0) #define PY_TRUFFLE_TYPE_UNIMPLEMENTED(GLOBAL_NAME) // empty return PY_TYPE_OBJECTS 0; #undef PY_TRUFFLE_TYPE_GENERIC +#undef PY_TRUFFLE_TYPE_LOCAL #undef PY_TRUFFLE_TYPE_EXTERN #undef PY_TRUFFLE_TYPE_UNIMPLEMENTED } -/** to be used from Java code only; calls INCREF */ -PyAPI_FUNC(void) GraalPyPrivate_INCREF(PyObject* obj) { - Py_INCREF(obj); -} - -/** to be used from Java code only; calls DECREF */ -PyAPI_FUNC(void) GraalPyPrivate_DECREF(PyObject* obj) { - Py_DECREF(obj); -} - -/** to be used from Java code only; calls '_Py_Dealloc' */ -PyAPI_FUNC(Py_ssize_t) -GraalPyPrivate_SUBREF(intptr_t ptr, Py_ssize_t value) -{ - PyObject *obj = (PyObject*)ptr; // avoid type attachment at the interop boundary -#ifndef NDEBUG - if (obj->ob_refcnt & 0xFFFFFFFF00000000L) { - char buf[1024]; - sprintf(buf, - "suspicious refcnt value during managed adjustment for %p (%zd 0x%zx - %zd)\n", - obj, obj->ob_refcnt, obj->ob_refcnt, value); - Py_FatalError(buf); - } - if ((obj->ob_refcnt - value) < 0) { - char buf[1024]; - sprintf(buf, - "refcnt below zero during managed adjustment for %p (%zd 0x%zx - %zd)\n", - obj, obj->ob_refcnt, obj->ob_refcnt, value); - Py_FatalError(buf); - } -#endif // NDEBUG - - Py_ssize_t new_value = ((obj->ob_refcnt) -= value); - if (new_value == 0) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINER, "%s: _Py_Dealloc(0x%zx)", - __func__, obj); - _Py_Dealloc(obj); - } -#ifdef Py_REF_DEBUG - else if (new_value < 0) { - _Py_NegativeRefcount(filename, lineno, op); - } -#endif - return new_value; -} - /** to be used from Java code only; calls '_Py_Dealloc' */ -PyAPI_FUNC(Py_ssize_t) +GraalPy_CAPI_HELPER_SYMBOL Py_ssize_t GraalPyPrivate_BulkDealloc(intptr_t ptrArray[], int64_t len) { for (int i = 0; i < len; i++) { - PyObject *obj = (PyObject*)ptrArray[i]; - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINER, "%s: _Py_Dealloc(0x%zx)", - __func__, obj); + PyObject *obj = (PyObject *)ptrArray[i]; + GraalPyPrivate_Log(GRAALPY_LOG_FINER, + "%s: _Py_Dealloc(a %s at 0x%zx)", + __func__, Py_TYPE(obj)->tp_name, obj); _Py_Dealloc(obj); } return 0; } /** to be used from Java code only and only at exit; calls _Py_Dealloc */ -PyAPI_FUNC(Py_ssize_t) +GraalPy_CAPI_HELPER_SYMBOL Py_ssize_t GraalPyPrivate_BulkDeallocOnShutdown(intptr_t ptrArray[], int64_t len) { /* some objects depends on others which might get deallocated in the @@ -450,7 +458,7 @@ GraalPyPrivate_BulkDeallocOnShutdown(intptr_t ptrArray[], int64_t len) /* we don't need to care about objects with default deallocation process */ obj->ob_refcnt = 0; - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINER, "%s: _Py_Dealloc(0x%zx)", + GraalPyPrivate_Log(GRAALPY_LOG_FINER, "%s: _Py_Dealloc(0x%zx)", __func__, obj); _Py_Dealloc(obj); } @@ -461,11 +469,11 @@ GraalPyPrivate_BulkDeallocOnShutdown(intptr_t ptrArray[], int64_t len) /* To be used from Java code only. * This function is used if a native class inherits from a managed class but uses the 'object.__new__'. * This function roughly corresponds to CPython's 'object_new'. */ -PyAPI_FUNC(PyObject*) GraalPyPrivate_ObjectNew(PyTypeObject* cls) { +GraalPy_CAPI_HELPER_SYMBOL PyObject* GraalPyPrivate_ObjectNew(PyTypeObject* cls) { return cls->tp_alloc(cls, 0); } -PyAPI_FUNC(void) GraalPyPrivate_ObjectArrayRelease(PyObject** array, int32_t size) { +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_ObjectArrayRelease(PyObject** array, int32_t size) { for (int i = 0; i < size; i++) { /* This needs to use 'Py_XDECREF' because we use this function to deallocate storages of tuples, lists, ..., where this is done in the @@ -483,7 +491,7 @@ PyAPI_FUNC(void) GraalPyPrivate_ObjectArrayRelease(PyObject** array, int32_t siz #include "psapi.h" #endif -PyAPI_FUNC(size_t) GraalPyPrivate_GetCurrentRSS() { +GraalPy_CAPI_HELPER_SYMBOL size_t GraalPyPrivate_GetCurrentRSS(void) { size_t rss = 0; #if defined(__APPLE__) && defined(__MACH__) // MacOS @@ -514,114 +522,8 @@ PyAPI_FUNC(size_t) GraalPyPrivate_GetCurrentRSS() { } -#define ReadMember(object, offset, T) ((T*)(((char*)object) + offset))[0] - -PyAPI_FUNC(int) GraalPyPrivate_ReadShortMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, short); -} - -PyAPI_FUNC(int) GraalPyPrivate_ReadIntMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, int); -} - -PyAPI_FUNC(long) GraalPyPrivate_ReadLongMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, long); -} - -PyAPI_FUNC(double) GraalPyPrivate_ReadFloatMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, float); -} - -PyAPI_FUNC(double) GraalPyPrivate_ReadDoubleMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, double); -} - -PyAPI_FUNC(void*) GraalPyPrivate_ReadPointerMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, void*); -} - -PyAPI_FUNC(int) GraalPyPrivate_ReadCharMember(void* object, Py_ssize_t offset) { - return ReadMember(object, offset, char); -} - -#define WriteMember(object, offset, value, T) *(T*)(((char*)object) + offset) = (T)(value) - -PyAPI_FUNC(int) GraalPyPrivate_WriteShortMember(void* object, Py_ssize_t offset, short value) { - WriteMember(object, offset, value, short); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteIntMember(void* object, Py_ssize_t offset, int value) { - WriteMember(object, offset, value, int); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteLongMember(void* object, Py_ssize_t offset, long value) { - WriteMember(object, offset, value, long); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteFloatMember(void* object, Py_ssize_t offset, double value) { - WriteMember(object, offset, value, float); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteDoubleMember(void* object, Py_ssize_t offset, double value) { - WriteMember(object, offset, value, double); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteObjectMember(void* object, Py_ssize_t offset, PyObject* value) { - /* We first need to decref the old value. */ - PyObject *oldv = ReadMember(object, offset, PyObject*); - Py_XINCREF(value); - WriteMember(object, offset, value, PyObject*); - Py_XDECREF(oldv); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WritePointerMember(void* object, Py_ssize_t offset, void* value) { - WriteMember(object, offset, value, void*); - return 0; -} - -PyAPI_FUNC(int) GraalPyPrivate_WriteCharMember(void* object, Py_ssize_t offset, char value) { - WriteMember(object, offset, value, char); - return 0; -} - -#undef ReadMember -#undef WriteMember - -PyAPI_FUNC(int) GraalPyPrivate_PointerCompare(void* x, void* y, int op) { - switch (op) { - case Py_LT: - return x < y; - case Py_LE: - return x <= y; - case Py_EQ: - return x == y; - case Py_NE: - return x != y; - case Py_GT: - return x > y; - case Py_GE: - return x >= y; - default: - return -1; - } -} - -PyAPI_FUNC(void*) GraalPyPrivate_PointerAddOffset(void* x, Py_ssize_t y) { - return (char *)x + y; -} - -PyAPI_FUNC(int) GraalPyPrivate_SubclassCheck(PyObject* type) { - return PyType_FastSubclass(Py_TYPE(type), Py_TPFLAGS_TYPE_SUBCLASS); -} - // Implements the basesisze check in typeobject.c:_PyObject_GetState -PyAPI_FUNC(int) GraalPyPrivate_CheckBasicsizeForGetstate(PyTypeObject* type, int slot_num) { +GraalPy_CAPI_HELPER_SYMBOL int GraalPyPrivate_CheckBasicsizeForGetstate(PyTypeObject* type, int slot_num) { Py_ssize_t basicsize = PyBaseObject_Type.tp_basicsize; if (type->tp_dictoffset) basicsize += sizeof(PyObject *); @@ -632,56 +534,34 @@ PyAPI_FUNC(int) GraalPyPrivate_CheckBasicsizeForGetstate(PyTypeObject* type, int return type->tp_basicsize > basicsize; } -PyAPI_FUNC(void) GraalPyPrivate_CheckTypeReady(PyTypeObject* type) { +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_CheckTypeReady(PyTypeObject* type) { if (!(type->tp_flags & Py_TPFLAGS_READY)) { PyType_Ready(type); } } -PyAPI_FUNC(void*) GraalPyPrivate_VaArgPointer(va_list* va) { - return va_arg(*va, void*); -} - -PyAPI_FUNC(void*) GraalPyPrivate_ConvertPointer(Py_ssize_t value) { - return (void*) value; -} - -PyAPI_FUNC(int) GraalPyPrivate_NoOpClear(PyObject* o) { +GraalPy_CAPI_HELPER_SYMBOL int GraalPyPrivate_NoOpClear(PyObject* o) { return 0; } -PyAPI_FUNC(int) GraalPyPrivate_NoOpTraverse(PyObject *self, visitproc visit, void *arg) { +GraalPy_CAPI_HELPER_SYMBOL int GraalPyPrivate_NoOpTraverse(PyObject *self, visitproc visit, void *arg) { return 0; } // defined in 'exceptions.c' -void initialize_exceptions(); +Py_LOCAL_SYMBOL void initialize_exceptions(); // defined in 'pyhash.c' -void initialize_hashes(); +Py_LOCAL_SYMBOL void initialize_hashes(); // defined in 'floatobject.c' void _PyFloat_InitState(PyInterpreterState* state); /* - * This is used to allow Truffle to enter/leave the context on native threads - * that were not created by NFI/Truffle/Java and thus not previously attached - * to the context. See e.g. PyGILState_Ensure. This is used by some C - * extensions to allow calling Python APIs from natively created threads. This - * poses a problem if multiple contexts use the same library, since we cannot - * know which context should be entered. CPython has the same problem (see - * https://docs.python.org/3/c-api/init.html#bugs-and-caveats), in particular - * the following quote: - * - * Furthermore, extensions (such as ctypes) using these APIs to allow calling - * of Python code from non-Python created threads will probably be broken - * when using sub-interpreters. - * - * If we try to use the same libpython for multiple contexts, we can only - * behave in a similar (likely broken) way as CPython: natively created threads - * that use the PyGIL_* APIs to allow calling into Python will attach to the - * first interpreter that initialized the C API (and thus set the - * TRUFFLE_CONTEXT pointer) only. + * These functions allow Truffle to enter/leave the context on native threads + * that were not created by Truffle/Java and thus do not have a previously + * entered polyglot context. See e.g. PyGILState_Ensure. */ -Py_LOCAL_SYMBOL TruffleContext* TRUFFLE_CONTEXT; +Py_LOCAL_SYMBOL graalpy_attach_native_thread_func graalpy_attach_native_thread = NULL; +Py_LOCAL_SYMBOL graalpy_detach_native_thread_func graalpy_detach_native_thread = NULL; /* * This is only set during VM shutdown, so on the native side can only be used @@ -691,14 +571,14 @@ Py_LOCAL_SYMBOL TruffleContext* TRUFFLE_CONTEXT; */ Py_LOCAL_SYMBOL int8_t *_graalpy_finalizing = NULL; -PyAPI_FUNC(void) initialize_graal_capi(TruffleEnv* env, void **builtin_closures, GCState *gc) { +PyAPI_FUNC(PyThreadState **) initialize_graal_capi(void **builtin_closures, GCState *gc, + PyThreadState *tstate, graalpy_attach_native_thread_func attach_native_thread, + graalpy_detach_native_thread_func detach_native_thread) { clock_t t = clock(); - if (env) { - TRUFFLE_CONTEXT = (*env)->getTruffleContext(env); - } - _PyGC_InitState(gc); + graalpy_attach_native_thread = attach_native_thread; + graalpy_detach_native_thread = detach_native_thread; /* * Initializing all these global fields with pointers to different contexts @@ -725,12 +605,12 @@ PyAPI_FUNC(void) initialize_graal_capi(TruffleEnv* env, void **builtin_closures, * context exits and its table is the "latest", we delay freeing it. */ initialize_builtins(builtin_closures); - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, "initialize_builtins: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "initialize_builtins: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); Py_Truffle_Options = GraalPyPrivate_Native_Options(); initialize_builtin_types_and_structs(); // initialize global variables like '_Py_NoneStruct', etc. - initialize_globals(); + initialize_globals(tstate); initialize_exceptions(); initialize_hashes(); initialize_bufferprocs(); @@ -740,14 +620,15 @@ PyAPI_FUNC(void) initialize_graal_capi(TruffleEnv* env, void **builtin_closures, // TODO: initialize during cext initialization doesn't work at the moment Py_FileSystemDefaultEncoding = "utf-8"; // strdup(PyUnicode_AsUTF8(GraalPyPrivate_FileSystemDefaultEncoding())); - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, "initialize_graal_capi: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "initialize_graal_capi: %fs", ((double) (clock() - t)) / CLOCKS_PER_SEC); + return &tstate_current; } /* * This function is called from Java during C API initialization to get the * pointer `_graalpy_finalizing`. */ -PyAPI_FUNC(int8_t *) GraalPyPrivate_GetFinalizeCApiPointer() { +GraalPy_CAPI_HELPER_SYMBOL void *GraalPyPrivate_GetFinalizeCApiPointer(void) { assert(!_graalpy_finalizing); // We actually leak this memory on purpose. On the Java side, this is // written to in a VM shutdown hook. Once such a hook is registered it diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.h b/graalpython/com.oracle.graal.python.cext/src/capi.h index 4ed779252b..965e6690b2 100644 --- a/graalpython/com.oracle.graal.python.cext/src/capi.h +++ b/graalpython/com.oracle.graal.python.cext/src/capi.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -65,6 +65,12 @@ #error "don't know how to declare thread local variable" #endif +typedef int (*graalpy_attach_native_thread_func)(void); +typedef void (*graalpy_detach_native_thread_func)(void); + +extern graalpy_attach_native_thread_func graalpy_attach_native_thread; +extern graalpy_detach_native_thread_func graalpy_detach_native_thread; + #ifdef MS_WINDOWS // define the below, otherwise windows' sdk defines complex to _complex and breaks us #define _COMPLEX_DEFINED @@ -87,16 +93,6 @@ #define SRC_CS "utf-8" -/* Flags definitions representing global (debug) options. */ -#define PY_TRUFFLE_TRACE_MEM 0x1 -#define PY_TRUFFLE_LOG_INFO 0x2 -#define PY_TRUFFLE_LOG_CONFIG 0x4 -#define PY_TRUFFLE_LOG_FINE 0x8 -#define PY_TRUFFLE_LOG_FINER 0x10 -#define PY_TRUFFLE_LOG_FINEST 0x20 -#define PY_TRUFFLE_DEBUG_CAPI 0x40 -#define PY_TRUFFLE_PYTHON_GC 0x80 - typedef struct mmap_object mmap_object; typedef struct _gc_runtime_state GCState; // originally in 'gcmodule.c' @@ -127,7 +123,7 @@ typedef struct { PyGC_Head *reachable; } GraalPyGC_Cycle; -PyAPI_FUNC(void) GraalPyPrivate_DebugTrace(void); +Py_LOCAL_SYMBOL void GraalPyPrivate_DebugTrace(void); typedef struct { PyObject_HEAD @@ -145,40 +141,71 @@ typedef struct { double ob_fval; } GraalPyFloatObject; +typedef struct { + GraalPyObject ob_base; + Py_ssize_t length; + Py_ssize_t byte_length; + Py_hash_t hash; + /* Bits 0-2: kind; bit 3: is_ascii; bits 4-5: interned state. */ + uint64_t state; + void *data; +} GraalPyUnicodeObject; + typedef struct gc_generation GCGeneration; +#define GraalPy_CAPI_HELPER_SYMBOL Py_LOCAL_SYMBOL + // {{start CAPI_BUILTINS}} #include "capi.gen.h" -#define PUBLIC_BUILTIN(NAME, RET, ...) extern PyAPI_FUNC(RET) (*GraalPyPrivate_Upcall_##NAME)(__VA_ARGS__); -#define PRIVATE_BUILTIN(NAME, RET, ...) extern PyAPI_FUNC(RET) (*NAME)(__VA_ARGS__); +#define PUBLIC_BUILTIN(NAME, RET, ...) extern Py_LOCAL_SYMBOL RET (*GraalPyPrivate_Upcall_##NAME)(__VA_ARGS__); +#define PRIVATE_BUILTIN(NAME, RET, ...) extern Py_LOCAL_SYMBOL RET (*NAME)(__VA_ARGS__); CAPI_BUILTINS #undef PUBLIC_BUILTIN #undef PRIVATE_BUILTIN #define GET_SLOT_SPECIAL(OBJ, RECEIVER, NAME, SPECIAL) ( points_to_py_handle_space(OBJ) ? GraalPyPrivate_Get_##RECEIVER##_##NAME((RECEIVER*) (OBJ)) : ((RECEIVER*) (OBJ))->SPECIAL ) -PyAPI_DATA(uint32_t) Py_Truffle_Options; +extern Py_LOCAL_SYMBOL uint32_t Py_Truffle_Options; extern THREAD_LOCAL Py_LOCAL_SYMBOL PyThreadState *tstate_current; +static inline void graalpy_initialize_thread_state_singletons(PyThreadState *tstate) { + if (tstate == NULL || GraalPyPrivate_Tuple_Empty == NULL || GraalPyPrivate_Bytes_Empty == NULL || GraalPyPrivate_Bytes_FromStringAndSize == NULL) { + return; + } + if (tstate->singletons.tuple_empty == NULL) { + tstate->singletons.tuple_empty = GraalPyPrivate_Tuple_Empty(); + } + if (tstate->singletons.bytes_empty == NULL) { + tstate->singletons.bytes_empty = GraalPyPrivate_Bytes_Empty(); + } + if (tstate->singletons.bytes_characters != NULL && tstate->singletons.bytes_characters[0] == NULL) { + for (int i = 0; i < 256; i++) { + char ch = (char)i; + tstate->singletons.bytes_characters[i] = GraalPyPrivate_Bytes_FromStringAndSize(&ch, 1); + if (tstate->singletons.bytes_characters[i] == NULL) { + Py_FatalError("failed to initialize GraalPy one-byte bytes singleton"); + } + } + } + if (tstate->singletons.tuple_empty == NULL || tstate->singletons.bytes_empty == NULL || tstate->singletons.bytes_characters == NULL || tstate->singletons.bytes_characters[0] == NULL) { + Py_FatalError("failed to initialize GraalPy thread-state singletons"); + } +} + extern Py_LOCAL_SYMBOL int8_t *_graalpy_finalizing; #define graalpy_finalizing (_graalpy_finalizing != NULL && *_graalpy_finalizing) +Py_LOCAL_SYMBOL void graalpy_dealloc_stack_grow(PyThreadState *tstate); +Py_LOCAL_SYMBOL void graalpy_dealloc_stack_push(PyThreadState *tstate, PyObject *op); +Py_LOCAL_SYMBOL void graalpy_dealloc_stack_pop(PyThreadState *tstate, PyObject *op); + #if (__linux__ && __GNU_LIBRARY__) #include #include -#include #include -static void print_c_stacktrace() { - fprintf(stderr, "Native stacktrace:\n"); - intptr_t stack[16]; - size_t stack_size = backtrace((void *)stack, sizeof(stack) / sizeof(stack[0])); - backtrace_symbols_fd((void *)stack, stack_size, STDERR_FILENO); - fflush(stderr); -} - static void attach_gdb() { pid_t my_pid = getpid(); char* pathname = "/bin/sh"; @@ -197,132 +224,67 @@ static void attach_gdb() { } } #else -static void print_c_stacktrace() { - // not supported -} - static void attach_gdb() { // not supported } #endif +Py_LOCAL_SYMBOL size_t GraalPyPrivate_CaptureStacktrace(void **frames, size_t max_depth, size_t skip); +Py_LOCAL_SYMBOL void GraalPyPrivate_PrintCapturedStacktrace(FILE *file, const char *header, void *const *frames, size_t depth); +Py_LOCAL_SYMBOL void GraalPyPrivate_PrintCurrentStacktrace(FILE *file, const char *header, size_t max_depth, size_t skip); +Py_LOCAL_SYMBOL void GraalPyPrivate_LogCapturedStacktrace(int level, const char *prefix, void *const *frames, size_t depth); +Py_LOCAL_SYMBOL void GraalPyPrivate_LogImpl(int level, const char *format, va_list args); + +static inline void print_c_stacktrace() { + GraalPyPrivate_PrintCurrentStacktrace(stderr, "Native stacktrace:\n", 16, 0); +} + /* Flags definitions representing global (debug) options. */ static MUST_INLINE int GraalPyPrivate_Trace_Memory() { - return Py_Truffle_Options & PY_TRUFFLE_TRACE_MEM; + return Py_Truffle_Options & GRAALPY_TRACE_MEM; } static MUST_INLINE int GraalPyPrivate_Log_Info() { - return Py_Truffle_Options & PY_TRUFFLE_LOG_INFO; + return Py_Truffle_Options & GRAALPY_LOG_INFO; } static MUST_INLINE int GraalPyPrivate_Log_Config() { - return Py_Truffle_Options & PY_TRUFFLE_LOG_CONFIG; + return Py_Truffle_Options & GRAALPY_LOG_CONFIG; } static MUST_INLINE int GraalPyPrivate_Log_Fine() { - return Py_Truffle_Options & PY_TRUFFLE_LOG_FINE; + return Py_Truffle_Options & GRAALPY_LOG_FINE; } static MUST_INLINE int GraalPyPrivate_Log_Finer() { - return Py_Truffle_Options & PY_TRUFFLE_LOG_FINER; + return Py_Truffle_Options & GRAALPY_LOG_FINER; } static MUST_INLINE int GraalPyPrivate_Log_Finest() { - return Py_Truffle_Options & PY_TRUFFLE_LOG_FINEST; + return Py_Truffle_Options & GRAALPY_LOG_FINEST; } static MUST_INLINE int GraalPyPrivate_Debug_CAPI() { - return Py_Truffle_Options & PY_TRUFFLE_DEBUG_CAPI; + return Py_Truffle_Options & GRAALPY_DEBUG_CAPI; } static MUST_INLINE int GraalPyPrivate_PythonGC() { - return Py_Truffle_Options & PY_TRUFFLE_PYTHON_GC; + return Py_Truffle_Options & GRAALPY_PYTHON_GC; +} +static MUST_INLINE int GraalPyPrivate_PoisonNativeMemoryOnFree() { + return Py_Truffle_Options & GRAALPY_POISON_NATIVE_MEMORY_ON_FREE; +} +static MUST_INLINE int GraalPyPrivate_SampleNativeMemoryAllocSites() { + return Py_Truffle_Options & GRAALPY_SAMPLE_NATIVE_MEMORY_ALLOC_SITES; } -static void +static inline void GraalPyPrivate_Log(int level, const char *format, ...) { if (Py_Truffle_Options & level) { - char buffer[1024]; va_list args; va_start(args, format); - vsprintf(buffer, format, args); - GraalPyPrivate_LogString(level, buffer); + GraalPyPrivate_LogImpl(level, format, args); va_end(args); } } Py_LOCAL_SYMBOL int is_builtin_type(PyTypeObject *tp); - -#define JWRAPPER_DIRECT 1 -#define JWRAPPER_FASTCALL 2 -#define JWRAPPER_FASTCALL_WITH_KEYWORDS 3 -#define JWRAPPER_KEYWORDS 4 -#define JWRAPPER_VARARGS 5 -#define JWRAPPER_NOARGS 6 -#define JWRAPPER_O 7 -#define JWRAPPER_METHOD 8 -#define JWRAPPER_UNSUPPORTED 9 -#define JWRAPPER_ALLOC 10 -#define JWRAPPER_GETATTR 11 -#define JWRAPPER_SETATTR 12 -#define JWRAPPER_RICHCMP 13 -#define JWRAPPER_SETITEM 14 -#define JWRAPPER_UNARYFUNC 15 -#define JWRAPPER_BINARYFUNC 16 -#define JWRAPPER_BINARYFUNC_L 17 -#define JWRAPPER_BINARYFUNC_R 18 -#define JWRAPPER_TERNARYFUNC 19 -#define JWRAPPER_TERNARYFUNC_R 20 -#define JWRAPPER_LT 21 -#define JWRAPPER_LE 22 -#define JWRAPPER_EQ 23 -#define JWRAPPER_NE 24 -#define JWRAPPER_GT 25 -#define JWRAPPER_GE 26 -#define JWRAPPER_ITERNEXT 27 -#define JWRAPPER_INQUIRY 28 -#define JWRAPPER_DELITEM 29 -#define JWRAPPER_GETITEM 30 -#define JWRAPPER_GETTER 31 -#define JWRAPPER_SETTER 32 -#define JWRAPPER_INITPROC 33 -#define JWRAPPER_HASHFUNC 34 -#define JWRAPPER_CALL 35 -#define JWRAPPER_SETATTRO 36 -#define JWRAPPER_DESCR_GET 37 -#define JWRAPPER_DESCR_SET 38 -#define JWRAPPER_LENFUNC 39 -#define JWRAPPER_OBJOBJPROC 40 -#define JWRAPPER_OBJOBJARGPROC 41 -#define JWRAPPER_NEW 42 -#define JWRAPPER_MP_DELITEM 43 -#define JWRAPPER_STR 44 -#define JWRAPPER_REPR 45 -#define JWRAPPER_DESCR_DELETE 46 -#define JWRAPPER_DELATTRO 47 -#define JWRAPPER_SSIZE_ARG 48 -#define JWRAPPER_VISITPROC 49 -#define JWRAPPER_TRAVERSEPROC 50 - - -static inline int get_method_flags_wrapper(int flags) { - if (flags < 0) - return JWRAPPER_DIRECT; - if ((flags & (METH_FASTCALL | METH_KEYWORDS | METH_METHOD)) == (METH_FASTCALL | METH_KEYWORDS | METH_METHOD)) - return JWRAPPER_METHOD; - if ((flags & (METH_FASTCALL | METH_KEYWORDS)) == (METH_FASTCALL | METH_KEYWORDS)) - return JWRAPPER_FASTCALL_WITH_KEYWORDS; - if (flags & METH_FASTCALL) - return JWRAPPER_FASTCALL; - if (flags & METH_KEYWORDS) - return JWRAPPER_KEYWORDS; - if (flags & METH_VARARGS) - return JWRAPPER_VARARGS; - if (flags & METH_NOARGS) - return JWRAPPER_NOARGS; - if (flags & METH_O) - return JWRAPPER_O; - return JWRAPPER_UNSUPPORTED; -} - -PyAPI_FUNC(void) GraalPyPrivate_Object_GC_Del(void *op); - // export the SizeT arg parse functions, because we use them in contrast to cpython on windows for core modules that we link dynamically PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, const char *, ...); PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, const char *, ...); @@ -351,8 +313,8 @@ PY_TRUFFLE_TYPE(_PyNotImplemented_Type, "NotImplementedType", & PY_TRUFFLE_TYPE(_PyWeakref_CallableProxyType, "_weakref.CallableProxyType", &PyType_Type, sizeof(PyWeakReference)) \ PY_TRUFFLE_TYPE(_PyWeakref_ProxyType, "_weakref.ProxyType", &PyType_Type, sizeof(PyWeakReference)) \ PY_TRUFFLE_TYPE(_PyWeakref_RefType, "_weakref.ReferenceType", &PyType_Type, sizeof(PyWeakReference)) \ -PY_TRUFFLE_TYPE(Arraytype, "array", &PyType_Type, sizeof(arrayobject)) \ -PY_TRUFFLE_TYPE(mmap_object_type, "mmap.mmap", &PyType_Type, 0) \ +PY_TRUFFLE_TYPE_LOCAL(Arraytype, "array", &PyType_Type, sizeof(arrayobject)) \ +PY_TRUFFLE_TYPE_LOCAL(mmap_object_type, "mmap.mmap", &PyType_Type, 0) \ PY_TRUFFLE_TYPE(PyArrayIter_Type, "arrayiterator", &PyType_Type, sizeof(arrayiterobject)) \ PY_TRUFFLE_TYPE(PyAsyncGen_Type, "async_generator", &PyType_Type, sizeof(PyAsyncGenObject)) \ PY_TRUFFLE_TYPE_WITH_ITEMSIZE(PyLong_Type, "int", &PyType_Type, offsetof(PyLongObject, long_value.ob_digit), sizeof(PyObject *)) \ @@ -395,16 +357,9 @@ PY_TRUFFLE_TYPE_GENERIC(PyUnicode_Type, "str", & PY_TRUFFLE_TYPE(PyWrapperDescr_Type, "wrapper_descriptor", &PyType_Type, sizeof(PyWrapperDescrObject)) \ PY_TRUFFLE_TYPE(PyZip_Type, "zip", &PyType_Type, sizeof(zipobject)) \ PY_TRUFFLE_TYPE(PyReversed_Type, "reversed", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(cycle_type, "cycle", &PyType_Type, sizeof(PyObject)) \ +PY_TRUFFLE_TYPE_LOCAL(cycle_type, "cycle", &PyType_Type, sizeof(PyObject)) \ PY_TRUFFLE_TYPE(PySeqIter_Type, "iterator", &PyType_Type, sizeof(PyObject)) \ PY_TRUFFLE_TYPE(PyEnum_Type, "enumerate", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(PyCSimpleType, "PyCSimpleType", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(PyCData_Type, "_CData", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(Simple_Type, "_SimpleCData", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(PyCStructType_Type, "PyCStructType", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(UnionType_Type, "_ctypes.UnionType", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(PyCPointerType_Type, "PyCPointerType", &PyType_Type, sizeof(PyObject)) \ -PY_TRUFFLE_TYPE(PyCArrayType_Type, "PyCArrayType", &PyType_Type, sizeof(PyObject)) \ PY_TRUFFLE_TYPE(PyCoro_Type, "coroutine", &PyType_Type, sizeof(PyCoroObject)) \ PY_TRUFFLE_TYPE(Py_GenericAliasType, "types.GenericAlias", &PyType_Type, sizeof(PyObject)) \ /* PyPickleBufferObject (PyObject_HEAD + Py_buffer + PyObject*) is defined within Objects/picklebufobject.c, so its not exposed. */ \ @@ -464,6 +419,7 @@ PY_TRUFFLE_TYPE_UNIMPLEMENTED(PyUnicodeIter_Type) \ #define PY_TRUFFLE_TYPE_WITH_ALLOC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ALLOC__, __DEALLOC__, __FREE__) PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, 0, __ALLOC__, __DEALLOC__, __FREE__, 0) #define PY_TRUFFLE_TYPE(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__) PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, 0, 0, 0, 0, 0) +#define PY_TRUFFLE_TYPE_LOCAL(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__) PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, 0, 0, 0, 0, 0) #define PY_TRUFFLE_TYPE_WITH_ITEMSIZE(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__) PY_TRUFFLE_TYPE_GENERIC(GLOBAL_NAME, __TYPE_NAME__, __SUPER_TYPE__, __SIZE__, __ITEMSIZE__, 0, 0, 0, 0) diff --git a/graalpython/com.oracle.graal.python.cext/src/capsule.c b/graalpython/com.oracle.graal.python.cext/src/capsule.c index 0ad9b8537b..be9b34b835 100644 --- a/graalpython/com.oracle.graal.python.cext/src/capsule.c +++ b/graalpython/com.oracle.graal.python.cext/src/capsule.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2021, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2021, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2021 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -10,11 +10,10 @@ #include "capi.h" -PyAPI_FUNC(PyTypeObject*) getPyCapsuleTypeReference() { +Py_LOCAL_SYMBOL PyTypeObject* getPyCapsuleTypeReference() { return &PyCapsule_Type; } -PyAPI_FUNC(void) GraalPyPrivate_Capsule_CallDestructor(PyObject* capsule, PyCapsule_Destructor destructor) { +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_Capsule_CallDestructor(PyObject* capsule, PyCapsule_Destructor destructor) { destructor(capsule); } - diff --git a/graalpython/com.oracle.graal.python.cext/src/ceval.c b/graalpython/com.oracle.graal.python.cext/src/ceval.c index f74e8406d2..0a253f27e6 100644 --- a/graalpython/com.oracle.graal.python.cext/src/ceval.c +++ b/graalpython/com.oracle.graal.python.cext/src/ceval.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -1790,8 +1790,8 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals, Py_DECREF(defaults); return res; #else // GraalPy change - if (globals == NULL) { - PyErr_SetString(PyExc_SystemError, "PyEval_EvalCodeEx: NULL globals"); + if (!PyDict_Check(globals)) { + PyErr_BadInternalCall(); return NULL; } return GraalPyPrivate_Eval_EvalCodeEx(_co, globals, locals != NULL ? locals : Py_None, diff --git a/graalpython/com.oracle.graal.python.cext/src/complexobject.c b/graalpython/com.oracle.graal.python.cext/src/complexobject.c index 1659e3510d..956482d44b 100644 --- a/graalpython/com.oracle.graal.python.cext/src/complexobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/complexobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -239,7 +239,7 @@ PyComplex_FromCComplex(Py_complex cval) return PyComplex_FromDoubles(cval.real, cval.imag); } -PyAPI_FUNC(PyObject *) // GraalPy change: expose the function for downcalls, rename +GraalPy_CAPI_HELPER_SYMBOL PyObject * // GraalPy change: helper-table entry for downcalls, rename GraalPyPrivate_Complex_SubtypeFromDoubles(PyTypeObject *type, double real, double imag) { Py_complex c; diff --git a/graalpython/com.oracle.graal.python.cext/src/context.c b/graalpython/com.oracle.graal.python.cext/src/context.c index 729c68a109..d4c2da07d7 100644 --- a/graalpython/com.oracle.graal.python.cext/src/context.c +++ b/graalpython/com.oracle.graal.python.cext/src/context.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -41,7 +41,7 @@ #include "capi.h" -PyObject marker_struct = { +static PyObject marker_struct = { _PyObject_EXTRA_INIT { _Py_IMMORTAL_REFCNT }, &PyBaseObject_Type diff --git a/graalpython/com.oracle.graal.python.cext/src/datetime.c b/graalpython/com.oracle.graal.python.cext/src/datetime.c index 5b985323e1..318ed40fdd 100644 --- a/graalpython/com.oracle.graal.python.cext/src/datetime.c +++ b/graalpython/com.oracle.graal.python.cext/src/datetime.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -2762,28 +2762,22 @@ delta_reduce(PyDateTime_Delta* self, PyObject *Py_UNUSED(ignored)) { return Py_BuildValue("ON", Py_TYPE(self), delta_getstate(self)); } -#endif // GraalPy change #define OFFSET(field) offsetof(PyDateTime_Delta, field) -// GraalPy change: different members static PyMemberDef delta_members[] = { - {"_days", T_INT, OFFSET(days), 0, + {"days", T_INT, OFFSET(days), READONLY, PyDoc_STR("Number of days.")}, - {"_seconds", T_INT, OFFSET(seconds), 0, + {"seconds", T_INT, OFFSET(seconds), READONLY, PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")}, - {"_microseconds", T_INT, OFFSET(microseconds), 0, + {"microseconds", T_INT, OFFSET(microseconds), READONLY, PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")}, - - {"_hashcode", T_PYSSIZET, OFFSET(hashcode), 0, - PyDoc_STR("hashcode")}, {NULL} }; -#if 0 // GraalPy change static PyMethodDef delta_methods[] = { {"total_seconds", delta_total_seconds, METH_NOARGS, PyDoc_STR("Total seconds in the duration.")}, @@ -2867,7 +2861,7 @@ static PyTypeObject PyDateTime_DeltaType = { 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ // GraalPy change: nulled - delta_members, /* tp_members */ + 0, /* tp_members */ // GraalPy change: nulled 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ @@ -2880,6 +2874,7 @@ static PyTypeObject PyDateTime_DeltaType = { 0, /* tp_free */ }; +#if 0 // GraalPy change /* * PyDateTime_Date implementation. */ @@ -2904,70 +2899,13 @@ date_day(PyDateTime_Date *self, void *unused) return PyLong_FromLong(GET_DAY(self)); } -// GraalPy-specific -static int -set_date_year(PyDateTime_Date *self, PyObject *value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_date_args(ival, 1, 1) < 0) { - return -1; - } - self->hashcode = -1; - SET_YEAR(self, ival); - return 0; -} - -// GraalPy-specific -static int -set_date_month(PyDateTime_Date *self, PyObject *value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_date_args(MINYEAR, ival, 1) < 0) { - return -1; - } - self->hashcode = -1; - SET_MONTH(self, ival); - return 0; -} - -// GraalPy-specific -static int -set_date_day(PyDateTime_Date *self, PyObject *value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_date_args(MINYEAR, 1, ival) < 0) { - return -1; - } - self->hashcode = -1; - SET_DAY(self, ival); - return 0; -} - -// GraalPy-specific -static PyObject * -base_hashcode(_PyDateTime_BaseTZInfo *self, void *unused) -{ - return PyLong_FromSsize_t(self->hashcode); -} - -// GraalPy-specific -static int -set_base_hashcode(_PyDateTime_BaseTZInfo *self, PyObject *value, void *unused) -{ - self->hashcode = (Py_hash_t) PyLong_AsSsize_t(value); - return 0; -} - -// GraalPy change: different members static PyGetSetDef date_getset[] = { - {"_year", (getter)date_year, (setter)set_date_year}, - {"_month", (getter)date_month, (setter)set_date_month}, - {"_day", (getter)date_day, (setter)set_date_day}, - {"_hashcode", (getter)base_hashcode, (setter)set_base_hashcode}, + {"year", (getter)date_year}, + {"month", (getter)date_month}, + {"day", (getter)date_day}, {NULL} }; -#if 0 // GraalPy change /* Constructors. */ static char *date_kws[] = {"year", "month", "day", NULL}; @@ -3581,7 +3519,6 @@ date_replace(PyDateTime_Date *self, PyObject *args, PyObject *kw) Py_DECREF(tuple); return clone; } -#endif // GraalPy change static Py_hash_t generic_hash(unsigned char *data, int len) @@ -3603,7 +3540,6 @@ date_hash(PyDateTime_Date *self) return self->hashcode; } -#if 0 // GraalPy change static PyObject * date_toordinal(PyDateTime_Date *self, PyObject *Py_UNUSED(ignored)) { @@ -3735,7 +3671,7 @@ static PyTypeObject PyDateTime_DateType = { 0, /* tp_as_number */ // GraalPy change: nulled 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ - (hashfunc)date_hash, /* tp_hash */ + 0, /* tp_hash */ // GraalPy change: nulled 0, /* tp_call */ 0, /* tp_str */ // GraalPy change: nulled 0, /* tp_getattro */ // GraalPy change: nulled @@ -3751,7 +3687,7 @@ static PyTypeObject PyDateTime_DateType = { 0, /* tp_iternext */ 0, /* tp_methods */ // GraalPy change: nulled 0, /* tp_members */ - date_getset, /* tp_getset */ + 0, /* tp_getset */ // GraalPy change: nulled 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ @@ -4223,7 +4159,6 @@ static PyTypeObject PyDateTime_TimeZoneType = { 0, /* tp_alloc */ timezone_new, /* tp_new */ }; -#endif // GraalPy change /* * PyDateTime_Time implementation. @@ -4270,92 +4205,13 @@ time_fold(PyDateTime_Time *self, void *unused) return PyLong_FromLong(TIME_GET_FOLD(self)); } -// GraalPy-specific -static PyObject * -set_time_hour(PyDateTime_Time *self, PyObject* value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_time_args(ival, 0, 0, 0, 0) < 0) { - return -1; - } - self->hashcode = -1; - TIME_SET_HOUR(self, ival); - return 0; -} - -// GraalPy-specific -static PyObject * -set_time_minute(PyDateTime_Time *self, PyObject* value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_time_args(0, ival, 0, 0, 0) < 0) { - return -1; - } - self->hashcode = -1; - TIME_SET_MINUTE(self, ival); - return 0; -} - -// GraalPy-specific -/* The name time_second conflicted with some platform header file. */ -static PyObject * -set_py_time_second(PyDateTime_Time *self, PyObject* value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_time_args(0, 0, ival, 0, 0) < 0) { - return -1; - } - self->hashcode = -1; - TIME_SET_SECOND(self, ival); - return 0; -} - -// GraalPy-specific -static PyObject * -set_time_microsecond(PyDateTime_Time *self, PyObject* value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_time_args(0, 0, 0, ival, 0) < 0) { - return -1; - } - self->hashcode = -1; - TIME_SET_MICROSECOND(self, ival); - return 0; -} - -// GraalPy-specific -static PyObject * -set_time_tzinfo(PyDateTime_Time *self, PyObject* value, void *unused) -{ - if (value != Py_None) { - Py_INCREF(value); - self->tzinfo = value; - } - return 0; -} - -// GraalPy-specific -static PyObject * -set_time_fold(PyDateTime_Time *self, PyObject* value, void *unused) -{ - int ival = _PyLong_AsInt(value); - if (check_time_args(0, 0, 0, 0, ival) < 0) { - return -1; - } - self->hashcode = -1; - TIME_SET_FOLD(self, ival); - return 0; -} - -// GraalPy change: different members static PyGetSetDef time_getset[] = { - {"_hour", (getter)time_hour, (setter)set_time_hour}, - {"_minute", (getter)time_minute, (setter)set_time_minute}, - {"_second", (getter)py_time_second, (setter)set_py_time_second}, - {"_microsecond", (getter)time_microsecond, (setter)set_time_microsecond}, - {"_tzinfo", (getter)time_tzinfo, (setter)set_time_tzinfo}, - {"_fold", (getter)time_fold, (setter)set_time_fold}, - {"_hashcode", (getter)base_hashcode, (setter)set_base_hashcode}, + {"hour", (getter)time_hour}, + {"minute", (getter)time_minute}, + {"second", (getter)py_time_second}, + {"microsecond", (getter)time_microsecond}, + {"tzinfo", (getter)time_tzinfo}, + {"fold", (getter)time_fold}, {NULL} }; @@ -4363,7 +4219,6 @@ static PyGetSetDef time_getset[] = { * Constructors. */ -#if 0 // GraalPy change static char *time_kws[] = {"hour", "minute", "second", "microsecond", "tzinfo", "fold", NULL}; @@ -4966,7 +4821,7 @@ static PyTypeObject PyDateTime_TimeType = { 0, /* tp_iternext */ 0, /* tp_methods */ // GraalPy change: nulled 0, /* tp_members */ - time_getset, /* tp_getset */ + 0, /* tp_getset */ // GraalPy change: nulled 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ @@ -4978,6 +4833,7 @@ static PyTypeObject PyDateTime_TimeType = { 0, /* tp_free */ }; +#if 0 // GraalPy change /* * PyDateTime_DateTime implementation. */ @@ -5108,7 +4964,6 @@ static PyGetSetDef datetime_getset[] = { * Constructors. */ -#if 0 // GraalPy change static char *datetime_kws[] = { "year", "month", "day", "hour", "minute", "second", "microsecond", "tzinfo", "fold", NULL @@ -6917,7 +6772,7 @@ static PyTypeObject PyDateTime_DateTimeType = { 0, /* tp_iternext */ 0, /* tp_methods */ // GraalPy change: nulled 0, /* tp_members */ - datetime_getset, /* tp_getset */ + 0, /* tp_getset */ // GraalPy change: nulled &PyDateTime_DateType, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ @@ -7408,7 +7263,7 @@ pretty bizarre, and a tzinfo subclass can override fromutc() if it is. // GraalPy additions -long +Py_LOCAL_SYMBOL long GraalPyPrivate_PyDateTime_GET_LONG_FIELD(PyObject* o, const char* field_name) { PyObject* attr = PyObject_GetAttrString(o, field_name); @@ -7431,8 +7286,8 @@ GraalPyPrivate_PyDateTime_GET_LONG_FIELD(PyObject* o, const char* field_name) } /** to be used from Java code only; returns the type ID for a PyDateTime_CAPI */ -PyAPI_FUNC(void) -GraalPyPrivate_InitNativeDateTime() +GraalPy_CAPI_HELPER_SYMBOL void +GraalPyPrivate_InitNativeDateTime(void) { /* safe native get/set descriptors */ PyGetSetDef* getsets_date = PyDateTime_DateType.tp_getset; @@ -7441,12 +7296,12 @@ GraalPyPrivate_InitNativeDateTime() PyMemberDef* members_delta = PyDateTime_DeltaType.tp_members; static int64_t datetime_types[] = { - &PyDateTime_DateType, "datetime.date", - &PyDateTime_DateTimeType, "datetime.datetime", - &PyDateTime_TimeType, "datetime.time", - &PyDateTime_DeltaType, "datetime.timedelta", - &PyDateTime_TZInfoType, "datetime.timezone", - NULL, NULL + (intptr_t)&PyDateTime_DateType, (intptr_t)"datetime.date", + (intptr_t)&PyDateTime_DateTimeType, (intptr_t)"datetime.datetime", + (intptr_t)&PyDateTime_TimeType, (intptr_t)"datetime.time", + (intptr_t)&PyDateTime_DeltaType, (intptr_t)"datetime.timedelta", + (intptr_t)&PyDateTime_TZInfoType, (intptr_t)"datetime.timezone", + 0, 0 }; GraalPyPrivate_InitBuiltinTypesAndStructs(datetime_types); @@ -7456,3 +7311,71 @@ GraalPyPrivate_InitNativeDateTime() GraalPyPrivate_Set_Native_Slots(&PyDateTime_TimeType, getsets_time, NULL); GraalPyPrivate_Set_Native_Slots(&PyDateTime_DeltaType, NULL, members_delta); } + +// Used from Java to initialize native subtypes +GraalPy_CAPI_HELPER_SYMBOL PyObject* +GraalPyPrivate_Time_SubtypeNew(PyTypeObject* type, int hour, int minute, int second, int usecond, PyObject* tzinfo, int fold) { + char aware = tzinfo != NULL; + PyDateTime_Time *self = (PyDateTime_Time *) (type->tp_alloc(type, aware)); + if (self != NULL) { + self->hastzinfo = aware; + self->hashcode = -1; + TIME_SET_HOUR(self, hour); + TIME_SET_MINUTE(self, minute); + TIME_SET_SECOND(self, second); + TIME_SET_MICROSECOND(self, usecond); + if (aware) { + self->tzinfo = Py_NewRef(tzinfo); + } + TIME_SET_FOLD(self, fold); + } + return (PyObject *)self; +} + +GraalPy_CAPI_HELPER_SYMBOL PyObject* +GraalPyPrivate_Date_SubtypeNew(PyTypeObject* type, int year, int month, int day) { + PyDateTime_Date *self = (PyDateTime_Date *)(type->tp_alloc(type, 0)); + if (self) { + self->hashcode = -1; + SET_YEAR(self, year); + SET_MONTH(self, month); + SET_DAY(self, day); + } + return (PyObject *)self; +} + +GraalPy_CAPI_HELPER_SYMBOL PyObject* +GraalPyPrivate_DateTime_SubtypeNew(PyTypeObject* type, int year, int month, int day, int hour, int minute, int second, int usecond, PyObject* tzinfo, int fold) { + char aware = tzinfo != NULL; + PyDateTime_DateTime *self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware)); + if (self != NULL) { + self->hastzinfo = aware; + self->hashcode = -1; + /* Date fields */ + SET_YEAR((PyDateTime_Date *)self, year); + SET_MONTH((PyDateTime_Date *)self, month); + SET_DAY((PyDateTime_Date *)self, day); + /* Time fields */ + DATE_SET_HOUR(self, hour); + DATE_SET_MINUTE(self, minute); + DATE_SET_SECOND(self, second); + DATE_SET_MICROSECOND(self, usecond); + if (aware) { + self->tzinfo = Py_NewRef(tzinfo); + } + DATE_SET_FOLD(self, fold); + } + return (PyObject *)self; +} + +GraalPy_CAPI_HELPER_SYMBOL PyObject* +GraalPyPrivate_TimeDelta_SubtypeNew(PyTypeObject* type, int days, int seconds, int microseconds) { + PyDateTime_Delta *self = (PyDateTime_Delta *) (type->tp_alloc(type, 0)); + if (self != NULL) { + self->hashcode = -1; + SET_TD_DAYS(self, days); + SET_TD_SECONDS(self, seconds); + SET_TD_MICROSECONDS(self, microseconds); + } + return (PyObject *) self; +} diff --git a/graalpython/com.oracle.graal.python.cext/src/descrobject.c b/graalpython/com.oracle.graal.python.cext/src/descrobject.c index 71d65e86ca..ab87d9513d 100644 --- a/graalpython/com.oracle.graal.python.cext/src/descrobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/descrobject.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -41,12 +41,10 @@ #include "capi.h" PyObject* PyDescr_NewClassMethod(PyTypeObject *type, PyMethodDef *method) { - int flags = method->ml_flags; return GraalPyPrivate_Descr_NewClassMethod(method, method->ml_name, method->ml_doc, - flags, - get_method_flags_wrapper(flags), + method->ml_flags, method->ml_meth, type); } diff --git a/graalpython/com.oracle.graal.python.cext/src/dictobject.c b/graalpython/com.oracle.graal.python.cext/src/dictobject.c index 56e95376d5..14faebd390 100644 --- a/graalpython/com.oracle.graal.python.cext/src/dictobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/dictobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -2317,12 +2317,22 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value) Py_DECREF(d); return NULL; } +#endif // GraalPy change /* Methods */ static void dict_dealloc(PyDictObject *mp) { + /* Special case for native dict subclasses: we need to + * prevent that the native part is free'd twice because + * the managed object still refers to the native part. + */ + if (!points_to_py_handle_space(mp)) { + GraalPyPrivate_Dict_UnlinkNativePart((PyObject *)mp); + Py_TYPE(mp)->tp_free((PyObject *)mp); + } +#if 0 // GraalPy change PyInterpreterState *interp = _PyInterpreterState_GET(); assert(Py_REFCNT(mp) == 0); Py_SET_REFCNT(mp, 1); @@ -2366,9 +2376,11 @@ dict_dealloc(PyDictObject *mp) Py_TYPE(mp)->tp_free((PyObject *)mp); } Py_TRASHCAN_END +#endif // GraalPy change } +#if 0 // GraalPy change static PyObject * dict_repr(PyDictObject *mp) { @@ -3074,7 +3086,7 @@ PyDict_Copy(PyObject *o) Py_DECREF(copy); return NULL; } - +#endif // GraalPy change Py_ssize_t PyDict_Size(PyObject *mp) { @@ -3082,9 +3094,12 @@ PyDict_Size(PyObject *mp) PyErr_BadInternalCall(); return -1; } + if (points_to_py_handle_space(mp)) { + return GraalPyPrivate_Object_Size(mp); + } return ((PyDictObject *)mp)->ma_used; } - +#if 0 // GraalPy change PyObject * PyDict_Keys(PyObject *mp) { @@ -3562,6 +3577,7 @@ Py_ssize_t _PyDict_SizeOf(PyDictObject *mp) { size_t res = _PyObject_SIZE(Py_TYPE(mp)); + if (mp->ma_values) { res += shared_keys_usable_size(mp->ma_keys) * sizeof(PyObject*); } @@ -3835,7 +3851,7 @@ PyTypeObject PyDict_Type = { "dict", sizeof(PyDictObject), 0, - 0, /* tp_dealloc */ // GraalPy change: nulled + (destructor)dict_dealloc, /* tp_dealloc */ 0, /* tp_vectorcall_offset */ 0, /* tp_getattr */ 0, /* tp_setattr */ diff --git a/graalpython/com.oracle.graal.python.cext/src/exceptions.c b/graalpython/com.oracle.graal.python.cext/src/exceptions.c index 7d64a73f9c..9cab823127 100644 --- a/graalpython/com.oracle.graal.python.cext/src/exceptions.c +++ b/graalpython/com.oracle.graal.python.cext/src/exceptions.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -46,13 +46,13 @@ PY_EXCEPTIONS #undef EXCEPTION -void initialize_exceptions() { +Py_LOCAL_SYMBOL void initialize_exceptions() { #define EXCEPTION(NAME) PyExc_##NAME = (PyObject*) GraalPyPrivate_Type(#NAME); PY_EXCEPTIONS #undef EXCEPTION } -PyAPI_FUNC(PyObject *) +GraalPy_CAPI_HELPER_SYMBOL PyObject * GraalPyPrivate_Exception_SubtypeNew(PyTypeObject *type, PyObject *args) { PyBaseExceptionObject *self; diff --git a/graalpython/com.oracle.graal.python.cext/src/floatobject.c b/graalpython/com.oracle.graal.python.cext/src/floatobject.c index 101505621d..ffa5ccf77f 100644 --- a/graalpython/com.oracle.graal.python.cext/src/floatobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/floatobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2017 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -145,11 +145,20 @@ PyFloat_GetInfo(void) return floatinfo; } +#endif PyObject * PyFloat_FromDouble(double fval) { PyFloatObject *op; + // GraalPy: different implementation + if (fval == (float)fval) { + return float_to_pointer(fval); + } else { + return GraalPyPrivate_Float_FromDouble(fval); + } +} +#if 0 // GraalPy change #if PyFloat_MAXFREELIST > 0 struct _Py_float_state *state = get_float_state(); op = state->free_list; @@ -323,6 +332,9 @@ PyFloat_AsDouble(PyObject *op) // GraalPy change: upcall for managed if (points_to_py_handle_space(op)) { + if (points_to_py_int_handle(op)) { + return (double)pointer_to_int64(op); + } return GraalPyPrivate_Float_AsDouble(op); } @@ -2661,6 +2673,9 @@ PyFloat_Unpack8(const char *data, int le) double GraalPyFloat_AS_DOUBLE(PyObject *op) { if (points_to_py_handle_space(op)) { + if (points_to_py_float_handle(op)) { + return pointer_to_double(op); + } return ((GraalPyFloatObject*) pointer_to_stub(op))->ob_fval; } else { return _PyFloat_CAST(op)->ob_fval; @@ -2669,12 +2684,11 @@ double GraalPyFloat_AS_DOUBLE(PyObject *op) { // not quite as in CPython, this assumes that x is already a double. The rest of // the implementation is in the Float constructor in Java -PyAPI_FUNC(PyObject*) +GraalPy_CAPI_HELPER_SYMBOL PyObject* GraalPyPrivate_Float_SubtypeNew(PyTypeObject *type, double x) { PyObject* newobj = type->tp_alloc(type, 0); if (newobj == NULL) { - Py_DECREF(newobj); return NULL; } ((PyFloatObject *)newobj)->ob_fval = x; diff --git a/graalpython/com.oracle.graal.python.cext/src/gcmodule.c b/graalpython/com.oracle.graal.python.cext/src/gcmodule.c index 82e606e4c5..842f2c59eb 100644 --- a/graalpython/com.oracle.graal.python.cext/src/gcmodule.c +++ b/graalpython/com.oracle.graal.python.cext/src/gcmodule.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -49,19 +49,19 @@ call_traverse(traverseproc traverse, PyObject *op, visitproc visit, void *arg) return 0; } if (!traverse) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "type '%.100s' is a GC type but tp_traverse is NULL", Py_TYPE((op))->tp_name); return 0; } else { if (_PyObject_IsFreed(op)) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "we tried to call tp_traverse on a freed object at %p (ctx %p)!", op, arg); return 0; } if (_PyObject_IsFreed((PyObject *)Py_TYPE(op))) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_FINE, + GraalPyPrivate_Log(GRAALPY_LOG_FINE, "we tried to call tp_traverse on an object at %p with a freed type at %p (ctx %p)!", op, Py_TYPE(op), arg); return 0; @@ -554,6 +554,13 @@ visit_weak_reachable(PyObject *op, PyGC_Head *reachable) return 0; } + /* Untracked objects cannot be weak candidates, even if they are reached + * from a container traversed in this phase. + */ + if (!_PyObject_GC_IS_TRACKED(op)) { + return 0; + } + PyGC_Head *gc = AS_GC(op); /* 'visit_reachable' tests at this point for 'gc_is_collecting(gc)'. @@ -563,10 +570,6 @@ visit_weak_reachable(PyObject *op, PyGC_Head *reachable) * 'NEXT_MASK_UNREACHABLE' is set. */ - // It would be a logic error elsewhere if the collecting flag were set on - // an untracked object. - assert(UNTAG(gc)->_gc_next != 0); - /* Note: one could expect that we need to test * 'gc_get_refs(gc) == MANAGED_REFCNT' but that's no longer true because in * the previous phase (i.e. 'move_unreachable') when we move the object into @@ -891,7 +894,11 @@ move_unreachable(PyGC_Head *young, PyGC_Head *unreachable, // GraalPy change: this branch, else branch is original CPython code cycle.head = NULL; cycle.n = 0; - assert (cycle.reachable == weak_candidates ); + /* GraalPy change: visit_collect_managed_referents forwards to + * visit_reachable(cycle->reachable), and 'cycle' is initialized + * with 'young'. + */ + assert(cycle.reachable == young); /* visit_collect_managed_referents is visit_reachable + capture the references into "cycle" */ CALL_TRAVERSE(traverse, op, visit_collect_managed_referents, (void *)&cycle); @@ -979,12 +986,25 @@ move_weak_reachable(PyGC_Head *young, PyGC_Head *weak_candidates) while (gc != young) { Py_ssize_t gc_refcnt = gc_get_refs(gc); - assert(gc_is_collecting(gc)); - + /* GraalPy change: unlike CPython's single-phase flow, objects moved to + * 'weak_candidates' already had PREV_MASK_COLLECTING cleared in + * move_unreachable() before this phase runs. visit_weak_reachable() + * depends on that state so it can rescue weak candidates without + * moving them through visit_reachable() again, so gc_is_collecting(gc) + * is not a valid invariant here. + */ + // assert(gc_is_collecting(gc)); /* This phase is done after 'move_unreachable' and so all object * remaining in 'young' must have a non-zero gc_refcnt. */ - assert(gc_refcnt); + /* GraalPy change: gc_refcnt is also not a stable CPython-style + * invariant here. During the weak-candidate flow we reuse '_gc_prev' + * for list linkage, so native gc_refs information for rescued objects + * is recovered via update_refs()/subtract_refs() and + * is_referenced_from_managed(), not by requiring gc_refcnt != 0 for + * every object we encounter in this phase. + */ + // assert(gc_refcnt); /* If gc_refcnt s not MANAGED_REFCNT, then we know that this object is * referenced from native (e.g. stored in a global field). In case that * 'gc_refcnt == MANAGED_REFCNT' we don't know if the object is only @@ -1331,8 +1351,10 @@ handle_legacy_finalizers(PyThreadState *tstate, GCState *gcstate, PyGC_Head *finalizers, PyGC_Head *old) { +#if 0 // GraalPy change: uncollectable objects are not supported assert(!_PyErr_Occurred(tstate)); - assert(gcstate->garbage != NULL); + // GraalPy change: we do not use this field + // assert(gcstate->garbage != NULL); PyGC_Head *gc = GC_NEXT(finalizers); for (; gc != finalizers; gc = GC_NEXT(gc)) { @@ -1345,6 +1367,7 @@ handle_legacy_finalizers(PyThreadState *tstate, } } } +#endif // GraalPy change gc_list_merge(finalizers, old); } @@ -1403,10 +1426,12 @@ delete_garbage(PyThreadState *tstate, GCState *gcstate, "refcount is too small"); if (gcstate->debug & DEBUG_SAVEALL) { +#if 0 // GraalPy change: uncollectable objects are not supported assert(gcstate->garbage != NULL); if (PyList_Append(gcstate->garbage, op) < 0) { _PyErr_Clear(tstate); } +#endif // GraalPy change } else { inquiry clear; @@ -1622,14 +1647,16 @@ gc_collect_main(PyThreadState *tstate, int generation, // _PyTime_t t1 = 0; /* initialize to prevent a compiler warning */ GCState *gcstate = graalpy_get_gc_state(tstate); // GraalPy change - if (GraalPyPrivate_DisableReferneceQueuePolling()) { + if (GraalPyPrivate_DisableReferenceQueuePolling()) { // reference queue polling is currently active; cannot proceed return m + n; } +#if 0 // GraalPy change: uncollectable objects are not supported // gc_collect_main() must not be called before _PyGC_Init // or after _PyGC_Fini() assert(gcstate->garbage != NULL); +#endif // GraalPy change assert(!_PyErr_Occurred(tstate)); if (gcstate->debug & DEBUG_STATS) { @@ -1779,7 +1806,7 @@ gc_collect_main(PyThreadState *tstate, int generation, PyDTrace_GC_DONE(n + m); } - GraalPyPrivate_EnableReferneceQueuePolling(); + GraalPyPrivate_EnableReferenceQueuePolling(); assert(!_PyErr_Occurred(tstate)); return n + m; @@ -2916,7 +2943,7 @@ PyUnstable_GC_VisitObjects(gcvisitobjects_t callback, void *arg) } -void +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_Object_GC_Del(void *op) { if (is_managed(op)) { @@ -2927,13 +2954,13 @@ GraalPyPrivate_Object_GC_Del(void *op) } /* Exposes 'gc_collect_impl' such that we can call it from Java. */ -PyAPI_FUNC(Py_ssize_t) +GraalPy_CAPI_HELPER_SYMBOL Py_ssize_t GraalPyPrivate_GC_Collect(int generation) { return gc_collect_impl(NULL, generation); } -PyAPI_FUNC(void) +Py_LOCAL_SYMBOL void _GraalPyObject_GC_NotifyOwnershipTransfer(PyObject *op) { if (!is_managed(op) && _PyObject_IS_GC(op) && _PyObject_GC_IS_TRACKED(op)) { diff --git a/graalpython/com.oracle.graal.python.cext/src/getargs.c b/graalpython/com.oracle.graal.python.cext/src/getargs.c index 742078b47e..bcfcd92826 100644 --- a/graalpython/com.oracle.graal.python.cext/src/getargs.c +++ b/graalpython/com.oracle.graal.python.cext/src/getargs.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -2078,13 +2078,13 @@ _parser_init(struct _PyArg_Parser *parser) static int parser_init(struct _PyArg_Parser *parser) { -#if 0 // GraalPy change // volatile as it can be modified by other threads // and should not be optimized or reordered by compiler if (*((volatile int *)&parser->initialized)) { assert(parser->kwtuple != NULL); return 1; } +#if 0 // GraalPy change (free-threading incompatible) PyThread_acquire_lock(_PyRuntime.getargs.mutex, WAIT_LOCK); // Check again if another thread initialized the parser // while we were waiting for the lock. diff --git a/graalpython/com.oracle.graal.python.cext/src/graalpy_stacktrace.c b/graalpython/com.oracle.graal.python.cext/src/graalpy_stacktrace.c new file mode 100644 index 0000000000..6e64e982c1 --- /dev/null +++ b/graalpython/com.oracle.graal.python.cext/src/graalpy_stacktrace.c @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "capi.h" + +#include +#include +#include +#include + +#if defined(MS_WINDOWS) +#include +#include +#elif (defined(__linux__) && defined(__GNU_LIBRARY__)) || defined(__APPLE__) +#include +#endif + +#define GRAALPY_NATIVE_STACK_MAX_NAME 1024 +#define GRAALPY_NATIVE_STACK_LINE_BUFFER 2048 +typedef void (*GraalPyStacktraceWriter)(void *ctx, const char *line); + +static void +render_unavailable_stacktrace(GraalPyStacktraceWriter writer, void *ctx) +{ + writer(ctx, ""); +} + +#if defined(MS_WINDOWS) + +static int +ensure_windows_symbols_initialized(void) +{ + static int initialized = 0; + if (!initialized) { + HANDLE process = GetCurrentProcess(); + SymSetOptions(SymGetOptions() | SYMOPT_LOAD_LINES | SYMOPT_UNDNAME); + if (!SymInitialize(process, NULL, TRUE)) { + return 0; + } + initialized = 1; + } + return 1; +} + +static const char * +windows_basename(const char *path) +{ + const char *slash = strrchr(path, '\\'); + const char *alt = strrchr(path, '/'); + const char *base = slash != NULL ? slash + 1 : path; + if (alt != NULL && (slash == NULL || alt > slash)) { + base = alt + 1; + } + return base; +} + +static void +render_windows_stacktrace(GraalPyStacktraceWriter writer, void *ctx, void *const *frames, size_t depth) +{ + HANDLE process = GetCurrentProcess(); + char line[GRAALPY_NATIVE_STACK_LINE_BUFFER]; + char symbol_buffer[sizeof(SYMBOL_INFO) + GRAALPY_NATIVE_STACK_MAX_NAME]; + PSYMBOL_INFO symbol = (PSYMBOL_INFO) symbol_buffer; + + memset(symbol_buffer, 0, sizeof(symbol_buffer)); + symbol->SizeOfStruct = sizeof(SYMBOL_INFO); + symbol->MaxNameLen = GRAALPY_NATIVE_STACK_MAX_NAME - 1; + + if (!ensure_windows_symbols_initialized()) { + for (size_t i = 0; i < depth; i++) { + snprintf(line, sizeof(line), "frame[%lu]: %p", + (unsigned long) i, (void *) frames[i]); + writer(ctx, line); + } + return; + } + + for (size_t i = 0; i < depth; i++) { + DWORD64 address = (DWORD64) (uintptr_t) frames[i]; + DWORD64 displacement = 0; + IMAGEHLP_LINE64 source_line; + DWORD source_displacement = 0; + char module_path[MAX_PATH] = {'\0'}; + const char *module_name = NULL; + HMODULE module = NULL; + + memset(&source_line, 0, sizeof(source_line)); + source_line.SizeOfStruct = sizeof(source_line); + + if (GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + (LPCSTR) frames[i], &module) && GetModuleFileNameA(module, module_path, MAX_PATH) > 0) { + module_name = windows_basename(module_path); + } + + if (SymFromAddr(process, address, &displacement, symbol)) { + if (SymGetLineFromAddr64(process, address, &source_displacement, &source_line)) { + if (module_name != NULL) { + snprintf(line, sizeof(line), "frame[%lu]: %s!%s+0x%llx (%s:%lu) [%p]", + (unsigned long) i, module_name, symbol->Name, (unsigned long long) displacement, + source_line.FileName, (unsigned long) source_line.LineNumber, (void *) frames[i]); + } else { + snprintf(line, sizeof(line), "frame[%lu]: %s+0x%llx (%s:%lu) [%p]", + (unsigned long) i, symbol->Name, (unsigned long long) displacement, + source_line.FileName, (unsigned long) source_line.LineNumber, (void *) frames[i]); + } + } else if (module_name != NULL) { + snprintf(line, sizeof(line), "frame[%lu]: %s!%s+0x%llx [%p]", + (unsigned long) i, module_name, symbol->Name, (unsigned long long) displacement, (void *) frames[i]); + } else { + snprintf(line, sizeof(line), "frame[%lu]: %s+0x%llx [%p]", + (unsigned long) i, symbol->Name, (unsigned long long) displacement, (void *) frames[i]); + } + } else if (module_name != NULL) { + snprintf(line, sizeof(line), "frame[%lu]: %s [%p]", + (unsigned long) i, module_name, (void *) frames[i]); + } else { + snprintf(line, sizeof(line), "frame[%lu]: %p", + (unsigned long) i, (void *) frames[i]); + } + writer(ctx, line); + } +} + +#elif (defined(__linux__) && defined(__GNU_LIBRARY__)) || defined(__APPLE__) + +static void +render_execinfo_stacktrace(GraalPyStacktraceWriter writer, void *ctx, void *const *frames, size_t depth) +{ + char **symbols = backtrace_symbols((void *const *) frames, (int) depth); + char line[GRAALPY_NATIVE_STACK_LINE_BUFFER]; + if (symbols == NULL) { + for (size_t i = 0; i < depth; i++) { + snprintf(line, sizeof(line), "frame[%lu]: %p", + (unsigned long) i, (void *) frames[i]); + writer(ctx, line); + } + return; + } + + for (size_t i = 0; i < depth; i++) { + snprintf(line, sizeof(line), "frame[%lu]: %s", (unsigned long) i, symbols[i]); + writer(ctx, line); + } + free(symbols); +} + +#endif + +Py_LOCAL_SYMBOL size_t +GraalPyPrivate_CaptureStacktrace(void **frames, size_t max_depth, size_t skip) +{ + if (frames == NULL || max_depth == 0) { + return 0; + } +#if defined(MS_WINDOWS) + return (size_t) CaptureStackBackTrace((ULONG) (skip + 1), (ULONG) max_depth, frames, NULL); +#elif (defined(__linux__) && defined(__GNU_LIBRARY__)) || defined(__APPLE__) + int raw_depth = backtrace(frames, (int) (max_depth + skip + 1)); + size_t depth = raw_depth > 0 ? (size_t) raw_depth : 0; + size_t start = depth > (skip + 1) ? (skip + 1) : depth; + size_t usable_depth = depth - start; + if (usable_depth > 0) { + memmove(frames, frames + start, usable_depth * sizeof(void *)); + } + return usable_depth; +#else + return 0; +#endif +} + +static void +render_stacktrace(GraalPyStacktraceWriter writer, void *ctx, void *const *frames, size_t depth) +{ + if (depth == 0) { + render_unavailable_stacktrace(writer, ctx); + return; + } +#if defined(MS_WINDOWS) + render_windows_stacktrace(writer, ctx, frames, depth); +#elif (defined(__linux__) && defined(__GNU_LIBRARY__)) || defined(__APPLE__) + render_execinfo_stacktrace(writer, ctx, frames, depth); +#else + (void) frames; + render_unavailable_stacktrace(writer, ctx); +#endif +} + +static void +file_writer(void *ctx, const char *line) +{ + fprintf((FILE *) ctx, "%s\n", line); +} + +Py_LOCAL_SYMBOL void +GraalPyPrivate_PrintCapturedStacktrace(FILE *file, const char *header, void *const *frames, size_t depth) +{ + if (header != NULL) { + fputs(header, file); + } + render_stacktrace(file_writer, file, frames, depth); + fflush(file); +} + +Py_LOCAL_SYMBOL void +GraalPyPrivate_PrintCurrentStacktrace(FILE *file, const char *header, size_t max_depth, size_t skip) +{ + void *frames[64]; + size_t depth = max_depth; + if (depth > (sizeof(frames) / sizeof(frames[0]))) { + depth = sizeof(frames) / sizeof(frames[0]); + } + depth = GraalPyPrivate_CaptureStacktrace(frames, depth, skip + 1); + GraalPyPrivate_PrintCapturedStacktrace(file, header, frames, depth); +} + +typedef struct { + int level; + const char *prefix; +} LogWriterCtx; + +static void +log_writer(void *ctx, const char *line) +{ + LogWriterCtx *log_ctx = (LogWriterCtx *) ctx; + if (log_ctx->prefix != NULL) { + GraalPyPrivate_Log(log_ctx->level, "%s%s\n", log_ctx->prefix, line); + } else { + GraalPyPrivate_Log(log_ctx->level, "%s\n", line); + } +} + +Py_LOCAL_SYMBOL void +GraalPyPrivate_LogCapturedStacktrace(int level, const char *prefix, void *const *frames, size_t depth) +{ + if ((Py_Truffle_Options & level) == 0) { + return; + } + LogWriterCtx log_ctx = {level, prefix}; + render_stacktrace(log_writer, &log_ctx, frames, depth); +} diff --git a/graalpython/com.oracle.graal.python.cext/src/listobject.c b/graalpython/com.oracle.graal.python.cext/src/listobject.c index 3dcb2e302d..f001263af4 100644 --- a/graalpython/com.oracle.graal.python.cext/src/listobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/listobject.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -48,7 +48,7 @@ _list_clear(PyListObject *a) /* Because XDECREF can recursively invoke operations on this list, we make it empty first. */ - i = GraalPyPrivate_List_TryGetItems((PyObject *)a, &item); + i = GraalPyPrivate_List_ClearManagedOrGetItems((PyObject *)a, &item); if (i > 0) { assert(item != NULL); while (--i >= 0) { diff --git a/graalpython/com.oracle.graal.python.cext/src/longobject.c b/graalpython/com.oracle.graal.python.cext/src/longobject.c index 6f8815271d..7962702ed8 100644 --- a/graalpython/com.oracle.graal.python.cext/src/longobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/longobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2017 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -54,9 +54,9 @@ class int "PyObject *" "&PyLong_Type" #define medium_value(x) ((stwodigits)_PyLong_CompactValue(x)) -#endif // GraalPy change #define IS_SMALL_INT(ival) (-_PY_NSMALLNEGINTS <= (ival) && (ival) < _PY_NSMALLPOSINTS) #define IS_SMALL_UINT(ival) ((ival) < _PY_NSMALLPOSINTS) +#endif // GraalPy change #define _MAX_STR_DIGITS_ERROR_FMT_TO_INT "Exceeds the limit (%d digits) for integer string conversion: value has %zd digits; use sys.set_int_max_str_digits() to increase the limit" #define _MAX_STR_DIGITS_ERROR_FMT_TO_STR "Exceeds the limit (%d digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit" @@ -85,10 +85,8 @@ is_medium_int(stwodigits x) static PyObject * get_small_int(sdigit ival) { - assert(IS_SMALL_INT(ival)); - // GraalPy change: use our array of pointers - PyObject *v = _PyLong_SMALL_INT_PTRS[_PY_NSMALLNEGINTS + ival]; - return v; + // GraalPy change - we tag 32-bit integers + return int32_to_pointer(ival); } #if 0 // GraalPy change @@ -334,14 +332,19 @@ PyObject * PyLong_FromLong(long ival) { // GraalPy change: different implementation - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); - } - return GraalPyPrivate_Long_FromLongLong((long long) ival); + return PyLong_FromLongLong((long long) ival); } -#if 0 // GraalPy change #define PYLONG_FROM_UINT(INT_TYPE, ival) \ + do { \ + if ((ival) <= INT32_MAX) { \ + return int32_to_pointer((int)(ival)); \ + } \ + return GraalPyPrivate_Long_FromUnsignedLongLong((unsigned long long)(ival)); \ + } while(0) + +#if 0 // GraalPy change +#define PYLONG_FROM_UINT_CPYTHON(INT_TYPE, ival) \ do { \ if (IS_SMALL_UINT(ival)) { \ return get_small_int((sdigit)(ival)); \ @@ -364,6 +367,7 @@ PyLong_FromLong(long ival) } \ return (PyObject *)v; \ } while(0) +#endif // GraalPy change /* Create a new int object from a C unsigned long int */ @@ -409,6 +413,7 @@ PyLong_FromDouble(double dval) return PyLong_FromLong((long)dval); } +#if 0 // GraalPy change PyLongObject *v; double frac; int i, ndig, expo, neg; @@ -444,8 +449,9 @@ PyLong_FromDouble(double dval) _PyLong_FlipSign(v); } return (PyObject *)v; -} #endif // GraalPy change + return GraalPyPrivate_Long_FromDouble(dval); +} /* Checking for overflow in PyLong_AsLong is a PITA since C doesn't define * anything about what happens when a signed integer operation overflows, @@ -477,6 +483,10 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow) PyErr_BadInternalCall(); return -1; } + if (points_to_py_int_handle(vv)) { + *overflow = 0; + return pointer_to_int64(vv); + } long result = (long) GraalPyPrivate_Long_AsPrimitive(vv, MODE_COERCE_SIGNED, sizeof(long)); if (result == -1L && PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_OverflowError)) { PyErr_Clear(); @@ -494,6 +504,9 @@ long PyLong_AsLong(PyObject *obj) { // GraalPy change: different implementation + if (points_to_py_int_handle(obj)) { + return pointer_to_int64(obj); + } return (long) GraalPyPrivate_Long_AsPrimitive(obj, MODE_COERCE_SIGNED, sizeof(long)); } @@ -520,6 +533,9 @@ _PyLong_AsInt(PyObject *obj) Py_ssize_t PyLong_AsSsize_t(PyObject *vv) { + if (points_to_py_int_handle(vv)) { + return pointer_to_int64(vv); + } return (Py_ssize_t) GraalPyPrivate_Long_AsPrimitive(vv, MODE_PINT_SIGNED, sizeof(Py_ssize_t)); } @@ -534,6 +550,14 @@ PyLong_AsUnsignedLong(PyObject *vv) PyErr_BadInternalCall(); return (unsigned long) -1; } + if (points_to_py_int_handle(vv)) { + long value = pointer_to_int64(vv); + if (value < 0) { + PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); + return (unsigned long) -1; + } + return (unsigned long) value; + } return (unsigned long) GraalPyPrivate_Long_AsPrimitive(vv, MODE_PINT_UNSIGNED, sizeof(unsigned long)); } @@ -544,6 +568,14 @@ size_t PyLong_AsSize_t(PyObject *vv) { // GraalPy change: different implementation + if (points_to_py_int_handle(vv)) { + long value = pointer_to_int64(vv); + if (value < 0) { + PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); + return (size_t) -1; + } + return (size_t) value; + } return (size_t) GraalPyPrivate_Long_AsPrimitive(vv, MODE_PINT_UNSIGNED, sizeof(size_t)); } @@ -588,23 +620,33 @@ PyLong_AsUnsignedLongMask(PyObject *op) PyErr_BadInternalCall(); return (unsigned long) -1; } + if (points_to_py_int_handle(op)) { + return pointer_to_int64(op); + } return (unsigned long) GraalPyPrivate_Long_AsPrimitive(op, MODE_COERCE_MASK, sizeof(unsigned long)); } -#if 0 // GraalPy change int _PyLong_Sign(PyObject *vv) { + assert(vv != NULL); + if (points_to_py_int_handle(vv)) { + int64_t value = pointer_to_int64(vv); + return (value > 0) - (value < 0); + } + PyLongObject *v = (PyLongObject *)vv; assert(v != NULL); assert(PyLong_Check(v)); +#if 0 // GraalPy change if (_PyLong_IsCompact(v)) { return _PyLong_CompactSign(v); } return _PyLong_NonCompactSign(v); -} #endif // GraalPy change + return 1 - (GraalPyPrivate_Long_lv_tag(v) & SIGN_MASK); +} static int bit_length_digit(digit x) @@ -616,10 +658,19 @@ bit_length_digit(digit x) return _Py_bit_length((unsigned long)x); } -#if 0 // GraalPy change size_t _PyLong_NumBits(PyObject *vv) { + assert(vv != NULL); + if (points_to_py_int_handle(vv)) { + int64_t value = pointer_to_int64(vv); + unsigned long magnitude = value < 0 ? (unsigned long)-value : (unsigned long)value; + return (size_t)_Py_bit_length(magnitude); + } + + return GraalPyPrivate_Long_NumBits(vv); + +#if 0 // GraalPy change PyLongObject *v = (PyLongObject *)vv; size_t result = 0; Py_ssize_t ndigits; @@ -645,8 +696,10 @@ _PyLong_NumBits(PyObject *vv) PyErr_SetString(PyExc_OverflowError, "int has too many bits " "to express in a platform size_t"); return (size_t)-1; +#endif // GraalPy change } +#if 0 // GraalPy change PyObject * _PyLong_FromByteArray(const unsigned char* bytes, size_t n, int little_endian, int is_signed) @@ -905,9 +958,9 @@ PyLong_FromVoidPtr(void *p) return PyLong_FromUnsignedLongLong((uint64_t)p); } -#if 0 // GraalPy change /* Get a C pointer from an int object. */ +#if 0 // GraalPy change void * PyLong_AsVoidPtr(PyObject *vv) { @@ -940,6 +993,16 @@ PyLong_AsVoidPtr(PyObject *vv) return NULL; return (void *)x; } +#else +void * +PyLong_AsVoidPtr(PyObject *vv) +{ + if (points_to_py_int_handle(vv)) { + return (void *)(uintptr_t)pointer_to_int64(vv); + } + + return (void *)GraalPyPrivate_Long_AsVoidPtr(vv); +} #endif // GraalPy change /* Initial long long support by Chris Herborth (chrish@qnx.com), later @@ -954,10 +1017,11 @@ PyObject * PyLong_FromLongLong(long long ival) { // GraalPy change: different implementation - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); + if ((int)ival == ival) { + return int32_to_pointer(ival); + } else { + return GraalPyPrivate_Long_FromLongLong(ival); } - return GraalPyPrivate_Long_FromLongLong(ival); } /* Create a new int object from a C Py_ssize_t. */ @@ -966,10 +1030,7 @@ PyObject * PyLong_FromSsize_t(Py_ssize_t ival) { // GraalPy change: different implementation - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); - } - return GraalPyPrivate_Long_FromLongLong((long long) ival); + return PyLong_FromLongLong((long long) ival); } /* Get a C long long int from an int object or any object that has an @@ -983,6 +1044,9 @@ PyLong_AsLongLong(PyObject *vv) PyErr_BadInternalCall(); return -1; } + if (points_to_py_int_handle(vv)) { + return pointer_to_int64(vv); + } return (long long) GraalPyPrivate_Long_AsPrimitive(vv, MODE_COERCE_SIGNED, sizeof(long long)); } @@ -997,6 +1061,14 @@ PyLong_AsUnsignedLongLong(PyObject *vv) PyErr_BadInternalCall(); return (unsigned long long)-1; } + if (points_to_py_int_handle(vv)) { + long value = pointer_to_int64(vv); + if (value < 0) { + PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); + return (unsigned long long) -1; + } + return (unsigned long long) value; + } return (unsigned long long) GraalPyPrivate_Long_AsPrimitive(vv, MODE_PINT_UNSIGNED, sizeof(unsigned long long)); } @@ -1042,6 +1114,9 @@ PyLong_AsUnsignedLongLongMask(PyObject *op) PyErr_BadInternalCall(); return (unsigned long long)-1; } + if (points_to_py_int_handle(op)) { + return pointer_to_int64(op); + } return (unsigned long long) GraalPyPrivate_Long_AsPrimitive(op, MODE_COERCE_MASK, sizeof(unsigned long long)); } @@ -2417,6 +2492,7 @@ PyLong_FromString(const char *str, char **pend, int base) { int sign = 1, error_if_nonzero = 0; const char *start, *orig_str = str; + int orig_base = base; PyObject *z = NULL; PyObject *strobj; Py_ssize_t slen; @@ -2481,7 +2557,6 @@ PyLong_FromString(const char *str, char **pend, int base) long long result = strtoll(str, &endptr, base); if (error_if_nonzero && result != 0) { // let upcall handle the error reporting - base = 0; break; } // POSIX.1-2008: strtoll must not set errno on success, and set @@ -2502,11 +2577,53 @@ PyLong_FromString(const char *str, char **pend, int base) } } if (!z) { - z = GraalPyPrivate_Long_FromString((char *)orig_str, base); - if (z) { - // TODO: we should probably set the **pend out argument + z = GraalPyPrivate_Long_FromString(orig_str, orig_base); + if (!z && pend) { + /* + * We have an exception already, but we need to redo the validation + * to compute pend. Adapted from long_from_string_base + */ + *pend = (char *)str; + const char *end, *p; + char prev = 0; + start = p = str; + /* Leading underscore not allowed. */ + if (*start == '_') { + return NULL; + } + /* Verify all characters are digits and underscores. */ + while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base || *p == '_') { + if (*p == '_') { + /* Double underscore not allowed. */ + if (prev == '_') { + *pend = (char *)(p - 1); + return NULL; + } + } + prev = *p; + ++p; + } + /* Trailing underscore not allowed. */ + if (prev == '_') { + *pend = (char *)(p - 1); + return NULL; + } + end = p; + *pend = (char *)end; + /* Reject empty strings */ + if (start == end) { + return NULL; + } + /* Allow only trailing whitespace after `end` */ + while (*p && Py_ISSPACE(*p)) { + p++; + } + *pend = (char *)p; } } + if (z && pend) { + *pend = (char *)(str + strlen(str)); + } return z; } @@ -6100,14 +6217,40 @@ PyUnstable_Long_CompactValue(const PyLongObject* op) { #endif // GraalPy change +#undef PyUnstable_Long_IsCompact + +int +PyUnstable_Long_IsCompact(const PyLongObject* op) { + return GraalPyPrivate_Long_lv_tag(op) < (2 << NON_SIZE_BITS); +} + #undef PyUnstable_Long_CompactValue -Py_ssize_t -PyUnstable_Long_CompactValue(const PyLongObject *op) { +Py_ssize_t PyUnstable_Long_CompactValue(const PyLongObject *op) { + if (points_to_py_int_handle(op)) { + return pointer_to_int64(op); + } return GraalPyPrivate_Long_AsPrimitive((PyObject*) op, MODE_PINT_SIGNED, sizeof(Py_ssize_t)); } // GraalPy additions -uintptr_t GraalPyPrivate_Long_lv_tag(const PyLongObject *op) { +Py_LOCAL_SYMBOL uintptr_t GraalPyPrivate_Long_lv_tag(const PyLongObject *op) { + if (points_to_py_int_handle(op)) { + int64_t t = pointer_to_int64(op); + if (t == 0) { + return SIGN_ZERO; + } + int64_t sign = 0; + if (t < 0) { + sign = SIGN_NEGATIVE; + t = -t; + } + int64_t size = 0; + while (t != 0) { + ++size; + t >>= PYLONG_BITS_IN_DIGIT; + } + return (size << NON_SIZE_BITS) | sign; + } return GET_SLOT_SPECIAL(op, PyLongObject, long_value_lv_tag, long_value.lv_tag); } diff --git a/graalpython/com.oracle.graal.python.cext/src/memoryobject.c b/graalpython/com.oracle.graal.python.cext/src/memoryobject.c index 296b6e4102..84e514a441 100644 --- a/graalpython/com.oracle.graal.python.cext/src/memoryobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/memoryobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -1503,7 +1503,7 @@ memoryview_toreadonly_impl(PyMemoryViewObject *self) /* getbuffer */ /**************************************************************************/ -int // GraalPy change: not static +Py_LOCAL_SYMBOL int // GraalPy change: hidden for capi.c memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags) { Py_buffer *base = &self->view; @@ -1582,7 +1582,7 @@ memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags) return 0; } -void // GraalPy change: not static +Py_LOCAL_SYMBOL void // GraalPy change: hidden for capi.c memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view) { self->exports--; @@ -3407,19 +3407,18 @@ PyTypeObject PyMemoryView_Type = { #endif // GraalPy change // GraalPy additions -/* called from memoryview implementation to do pointer arithmetics currently not possible from Java */ -PyAPI_FUNC(int8_t *) -GraalPyPrivate_AddSuboffset(int8_t *ptr, Py_ssize_t offset, Py_ssize_t suboffset) -{ - return *(int8_t**)(ptr + offset) + suboffset; -} -PyAPI_FUNC(PyObject *) +GraalPy_CAPI_HELPER_SYMBOL PyObject * GraalPyPrivate_MemoryViewFromObject(PyObject *v, int flags) { if (PyObject_CheckBuffer(v)) { Py_buffer* buffer = malloc(sizeof(Py_buffer)); + if (buffer == NULL) { + PyErr_NoMemory(); + return NULL; + } if (PyObject_GetBuffer(v, buffer, flags) < 0) { + free(buffer); return NULL; } int needs_release = 0; @@ -3442,6 +3441,11 @@ GraalPyPrivate_MemoryViewFromObject(PyObject *v, int flags) buffer->shape, buffer->strides, buffer->suboffsets); + if (mv == NULL) { + PyBuffer_Release(buffer); + free(buffer); + return NULL; + } if (!needs_release) { free(buffer); } @@ -3455,7 +3459,7 @@ GraalPyPrivate_MemoryViewFromObject(PyObject *v, int flags) } /* Release buffer struct allocated in GraalPyPrivate_MemoryViewFromObject */ -PyAPI_FUNC(void) +GraalPy_CAPI_HELPER_SYMBOL void GraalPyPrivate_ReleaseBuffer(Py_buffer* buffer) { if (buffer->obj != NULL) { diff --git a/graalpython/com.oracle.graal.python.cext/src/methodobject.c b/graalpython/com.oracle.graal.python.cext/src/methodobject.c index d8c6edc030..14a4e14c24 100644 --- a/graalpython/com.oracle.graal.python.cext/src/methodobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/methodobject.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -45,8 +45,6 @@ /* undefine macro trampoline to PyCMethod_New */ #undef PyCFunction_NewEx -typedef PyObject *(*PyCFunction)(PyObject *, PyObject *); - PyObject *PyCFunction_New(PyMethodDef *ml, PyObject *self) { return PyCFunction_NewEx(ml, self, NULL); } @@ -56,42 +54,49 @@ PyObject *PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module) { } -PyObject* PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *cls) { - return GraalPyPrivate_CMethod_NewEx(ml, ml->ml_name, - ml->ml_meth, - ml->ml_flags, - get_method_flags_wrapper(ml->ml_flags), - self, - module, - cls, - ml->ml_doc); +PyObject *PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *cls) { + // GraalPy change: different implementation + int is_method = ml->ml_flags & METH_METHOD; + if (is_method && !cls) { + PyErr_SetString(PyExc_SystemError, + "attempting to create PyCMethod with a METH_METHOD " + "flag but no class"); + return NULL; + } + if (!is_method && cls) { + PyErr_SetString(PyExc_SystemError, + "attempting to create PyCFunction with class " + "but no METH_METHOD flag"); + return NULL; + } + return GraalPyPrivate_CMethod_NewEx(ml, ml->ml_name, ml->ml_meth, ml->ml_flags, self, module, cls, ml->ml_doc); } PyCFunction PyCFunction_GetFunction(PyObject *func) { - PyMethodDef* def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); + PyMethodDef *def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); return def->ml_meth; } -PyObject * PyCFunction_GetSelf(PyObject *func) { - PyMethodDef* def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); +PyObject *PyCFunction_GetSelf(PyObject *func) { + PyMethodDef *def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); return def->ml_flags & METH_STATIC ? NULL : GraalPyPrivate_GET_PyCFunctionObject_m_self(func); } int PyCFunction_GetFlags(PyObject *func) { - PyMethodDef* def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); + PyMethodDef *def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); return def->ml_flags; } -PyTypeObject * GraalPyCMethod_GetClass(PyObject *func) { - PyMethodDef* def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); +PyTypeObject *GraalPyCMethod_GetClass(PyObject *func) { + PyMethodDef *def = GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); return def->ml_flags & METH_METHOD ? GraalPyPrivate_GET_PyCMethodObject_mm_class(func) : NULL; } -PyObject* GraalPyCFunction_GetModule(PyObject *func) { +PyObject *GraalPyCFunction_GetModule(PyObject *func) { return GraalPyPrivate_GET_PyCFunctionObject_m_module(func); } -PyMethodDef* GraalPyCFunction_GetMethodDef(PyObject *func) { +PyMethodDef *GraalPyCFunction_GetMethodDef(PyObject *func) { return GraalPyPrivate_GET_PyCFunctionObject_m_ml(func); } diff --git a/graalpython/com.oracle.graal.python.cext/src/moduleobject.c b/graalpython/com.oracle.graal.python.cext/src/moduleobject.c index c7b8644dd2..5ddb615d9f 100644 --- a/graalpython/com.oracle.graal.python.cext/src/moduleobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/moduleobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2022, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2022, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -167,10 +167,11 @@ check_api_version(const char *name, int module_api_version) return 1; } -#if 0 // GraalPy change static int _add_methods_to_object(PyObject *module, PyObject *name, PyMethodDef *functions) { + return GraalPyPrivate_AddMethodsToObject(module, name, functions); +#if 0 // GraalPy change PyObject *func; PyMethodDef *fdef; @@ -194,8 +195,8 @@ _add_methods_to_object(PyObject *module, PyObject *name, PyMethodDef *functions) } return 0; -} #endif // GraalPy change +} PyObject * PyModule_Create2(PyModuleDef* module, int module_api_version) @@ -408,16 +409,10 @@ PyModule_FromDefAndSpec2(PyModuleDef* def, PyObject *spec, int module_api_versio } if (def->m_methods != NULL) { - // GraalPy change: use PyModule_AddFunctions instead of _add_methods_to_object - if (PyModule_AddFunctions(m, def->m_methods) != 0) { - Py_DECREF(m); - return NULL; + ret = _add_methods_to_object(m, nameobj, def->m_methods); + if (ret != 0) { + goto error; } - // End of GraalPy change, original code below - // ret = _add_methods_to_object(m, nameobj, def->m_methods); - // if (ret != 0) { - // goto error; - // } } if (def->m_doc != NULL) { @@ -519,19 +514,11 @@ int PyModule_AddFunctions(PyObject *m, PyMethodDef *functions) { // GraalPy change: different implementation - if (!functions) { + if (!PyModule_Check(m)) { + PyErr_BadArgument(); return -1; } - for (PyMethodDef* def = functions; def->ml_name != NULL; def++) { - GraalPyPrivate_Module_AddFunctionToModule(def, - m, - def->ml_name, - def->ml_meth, - def->ml_flags, - get_method_flags_wrapper(def->ml_flags), - def->ml_doc); - } - return 0; + return GraalPyPrivate_Module_AddFunctions(m, functions); } #if 0 // GraalPy change diff --git a/graalpython/com.oracle.graal.python.cext/src/object.c b/graalpython/com.oracle.graal.python.cext/src/object.c index da95198e2b..230a49414e 100644 --- a/graalpython/com.oracle.graal.python.cext/src/object.c +++ b/graalpython/com.oracle.graal.python.cext/src/object.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -309,7 +309,7 @@ _Py_IncRef(PyObject *o) { // GraalPy change: different implementation const Py_ssize_t refcnt = Py_REFCNT(o); - if (refcnt != IMMORTAL_REFCNT) + if (refcnt != _Py_IMMORTAL_REFCNT) { Py_SET_REFCNT(o, refcnt + 1); if (refcnt == MANAGED_REFCNT) { @@ -337,7 +337,7 @@ _Py_DecRef(PyObject *o) return; } const Py_ssize_t refcnt = Py_REFCNT(o); - if (refcnt != IMMORTAL_REFCNT) { + if (refcnt != _Py_IMMORTAL_REFCNT) { const Py_ssize_t updated_refcnt = refcnt - 1; Py_SET_REFCNT(o, updated_refcnt); if (updated_refcnt != 0) { @@ -531,6 +531,9 @@ int _PyObject_IsFreed(PyObject *op) { if (points_to_py_handle_space(op)) { + if (points_to_py_float_handle(op) || points_to_py_int_handle(op)) { + return 0; + } return GraalPyPrivate_Object_IsFreed(op); } #if 0 // GraalPy change @@ -1773,7 +1776,6 @@ PyObject_GenericSetDict(PyObject *obj, PyObject *value, void *context) } -#if 0 // GraalPy change /* Test a value used as condition, e.g., in a while or if statement. Return -1 if an error occurred */ @@ -1787,6 +1789,9 @@ PyObject_IsTrue(PyObject *v) return 0; if (v == Py_None) return 0; + // GraalPy change: upcall for managed objects + if (points_to_py_handle_space(v)) + return GraalPyPrivate_Object_IsTrue(v); else if (Py_TYPE(v)->tp_as_number != NULL && Py_TYPE(v)->tp_as_number->nb_bool != NULL) res = (*Py_TYPE(v)->tp_as_number->nb_bool)(v); @@ -1801,7 +1806,6 @@ PyObject_IsTrue(PyObject *v) /* if it is negative, it should be either -1 or -2 */ return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int); } -#endif // GraalPy change /* equivalent of 'not v' Return -1 if an error occurred */ @@ -1816,7 +1820,6 @@ PyObject_Not(PyObject *v) return res == 0; } -#if 0 // GraalPy change /* Test whether an object can be called */ int @@ -1827,6 +1830,7 @@ PyCallable_Check(PyObject *x) return Py_TYPE(x)->tp_call != NULL; } +#if 0 // GraalPy change /* Helper for PyObject_Dir without arguments: returns the local scope. */ static PyObject * @@ -2738,14 +2742,18 @@ _PyObject_AssertFailed(PyObject *obj, const char *expr, const char *msg, Py_FatalError("_PyObject_AssertFailed"); } - void _Py_Dealloc(PyObject *op) { + if (points_to_py_handle_space(op) && _PyObject_IS_GC(op)) { + GraalPyPrivate_ManagedObject_GC_Del(op); + return; + } + + PyThreadState *tstate = _PyThreadState_GET(); PyTypeObject *type = Py_TYPE(op); destructor dealloc = type->tp_dealloc; #ifdef Py_DEBUG - PyThreadState *tstate = _PyThreadState_GET(); PyObject *old_exc = tstate != NULL ? tstate->current_exception : NULL; // Keep the old exception type alive to prevent undefined behavior // on (tstate->curexc_type != old_exc_type) below @@ -2757,7 +2765,13 @@ _Py_Dealloc(PyObject *op) #ifdef Py_TRACE_REFS _Py_ForgetReference(op); #endif + if (tstate != NULL) { + graalpy_dealloc_stack_push(tstate, op); + } (*dealloc)(op); + if (tstate != NULL) { + graalpy_dealloc_stack_pop(tstate, op); + } #ifdef Py_DEBUG // gh-89373: The tp_dealloc function must leave the current exception @@ -2847,9 +2861,12 @@ Py_ssize_t Py_REFCNT(PyObject *obj) { Py_ssize_t res; if (points_to_py_handle_space(obj)) { + if (points_to_py_int_handle(obj) || points_to_py_float_handle(obj)) { + return _Py_IMMORTAL_REFCNT; + } res = pointer_to_stub(obj)->ob_refcnt; #ifndef NDEBUG - if (GraalPyPrivate_Debug_CAPI() && GraalPyPrivate_GET_PyObject_ob_refcnt(obj) != res) + if (GraalPyPrivate_Debug_CAPI() && GraalPyPrivate_Get_PyObject_ob_refcnt(obj) != res) { Py_FatalError("Refcount of native stub and managed object differ"); } @@ -2876,18 +2893,9 @@ void _Py_SetRefcnt(PyObject* obj, Py_ssize_t cnt) { return; } PyObject *dest; - if (points_to_py_handle_space(obj)) - { + if (points_to_py_handle_space(obj)) { dest = pointer_to_stub(obj); -#ifndef NDEBUG - if (GraalPyPrivate_Debug_CAPI()) - { - set_PyObject_ob_refcnt(obj, cnt); - } -#endif - } - else - { + } else { dest = obj; } dest->ob_refcnt = cnt; @@ -2897,6 +2905,12 @@ PyTypeObject* GraalPy_TYPE(PyObject *a) { PyTypeObject *res; if (points_to_py_handle_space(a)) { + if (points_to_py_float_handle(a)) { + return &PyFloat_Type; + } + if (points_to_py_int_handle(a)) { + return &PyLong_Type; + } res = pointer_to_stub(a)->ob_type; #ifndef NDEBUG if (GraalPyPrivate_Debug_CAPI() && GraalPyPrivate_GET_PyObject_ob_type(a) != res) @@ -2957,7 +2971,7 @@ void GraalPy_SET_TYPE(PyObject *a, PyTypeObject *b) { if (points_to_py_handle_space(a)) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_INFO, + GraalPyPrivate_Log(GRAALPY_LOG_INFO, "changing the type of an object is not supported\n"); } else { a->ob_type = b; @@ -2995,8 +3009,7 @@ _decref_notify(const PyObject *op, const Py_ssize_t updated_refcnt) GraalPyPrivate_BulkNotifyRefCount(deferred_notify_ops, DEFERRED_NOTIFY_SIZE); } #else - PyObject *nonConstOp = (PyObject *)op; - GraalPyPrivate_BulkNotifyRefCount(&nonConstOp, 1); + GraalPyPrivate_NotifyRefCount((PyObject *) op, updated_refcnt); #endif } } diff --git a/graalpython/com.oracle.graal.python.cext/src/obmalloc.c b/graalpython/com.oracle.graal.python.cext/src/obmalloc.c index ae39e1adac..6683b778df 100644 --- a/graalpython/com.oracle.graal.python.cext/src/obmalloc.c +++ b/graalpython/com.oracle.graal.python.cext/src/obmalloc.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -50,12 +50,28 @@ typedef struct { size_t dummy; } mem_head_t; +#define GRAALPY_MEM_SAMPLE_USEFUL_DEPTH (10) + +typedef struct { + void *ptr; + void *stack[GRAALPY_MEM_SAMPLE_USEFUL_DEPTH]; + size_t size; + size_t depth; + unsigned long long serial; + char operation; +} GraalPyMemSample_t; + /* Get an object's GC head */ #define AS_MEM_HEAD(o) ((mem_head_t *)(o)-1) /* Get the object given the GC head */ #define FROM_MEM_HEAD(g) ((void *)(((mem_head_t *)g)+1)) +#define GRAALPY_MEM_HEAD_MAGIC ((size_t)0x47505241574D454DULL) +#define GRAALPY_MEM_HEAD_POISON ((size_t)0xDDDDBAD0DDDDBAD0ULL) +#define GRAALPY_MEM_SAMPLE_RING_SIZE (4096) +#define GRAALPY_MEM_SAMPLE_HISTORY (8) +#define GRAALPY_MEM_SAMPLE_STACK_SKIP (2) #define MAX_COLLECTION_RETRIES (7) #define COLLECTION_DELAY_INCREMENT (50) @@ -72,6 +88,113 @@ typedef struct { } GraalPyMem_t; static GraalPyMem_t _GraalPyMem_State = { 0, 0, 0 }; +static GraalPyMemSample_t _GraalPyMem_Samples[GRAALPY_MEM_SAMPLE_RING_SIZE] = {{0}}; +static unsigned long long _GraalPyMem_SampleSerial = 0; +static size_t _GraalPyMem_SampleIndex = 0; + +static MUST_INLINE int +_GraalPyMem_PoisonOnFreeEnabled(void) +{ + return GraalPyPrivate_PoisonNativeMemoryOnFree(); +} + +static MUST_INLINE int +_GraalPyMem_SampleAllocSitesEnabled(void) +{ + return GraalPyPrivate_SampleNativeMemoryAllocSites(); +} + +static void +_GraalPyMem_CaptureSampleStack(GraalPyMemSample_t *sample) +{ + sample->depth = GraalPyPrivate_CaptureStacktrace(sample->stack, GRAALPY_MEM_SAMPLE_USEFUL_DEPTH, + GRAALPY_MEM_SAMPLE_STACK_SKIP); +} + +static void +_GraalPyMem_RecordSample(char operation, void *ptr, size_t size) +{ + if (UNLIKELY(ptr == NULL)) { + return; + } + if (LIKELY(!_GraalPyMem_SampleAllocSitesEnabled())) { + return; + } + + size_t index = _GraalPyMem_SampleIndex++ % GRAALPY_MEM_SAMPLE_RING_SIZE; + GraalPyMemSample_t *sample = &_GraalPyMem_Samples[index]; + sample->ptr = ptr; + sample->size = size; + sample->serial = ++_GraalPyMem_SampleSerial; + sample->operation = operation; + _GraalPyMem_CaptureSampleStack(sample); +} + +static void +_GraalPyMem_LogRecentSamples(const char *func, void *ptr) +{ + if (LIKELY(!_GraalPyMem_SampleAllocSitesEnabled())) { + return; + } + + size_t next_index = _GraalPyMem_SampleIndex; + int printed = 0; + for (size_t offset = 0; offset < GRAALPY_MEM_SAMPLE_RING_SIZE && printed < GRAALPY_MEM_SAMPLE_HISTORY; offset++) { + size_t index = (next_index + GRAALPY_MEM_SAMPLE_RING_SIZE - offset - 1) % GRAALPY_MEM_SAMPLE_RING_SIZE; + const GraalPyMemSample_t *sample = &_GraalPyMem_Samples[index]; + if (sample->ptr == ptr && sample->serial != 0) { + char prefix[128]; + GraalPyPrivate_Log(GRAALPY_LOG_INFO, + "%s: recent raw memory sample #%llu op=%c ptr=%p size=%lu depth=%lu\n", + func, sample->serial, sample->operation, sample->ptr, (unsigned long) sample->size, (unsigned long) sample->depth); + snprintf(prefix, sizeof(prefix), "%s: sample #%llu ", func, sample->serial); + GraalPyPrivate_LogCapturedStacktrace(GRAALPY_LOG_INFO, prefix, sample->stack, sample->depth); + printed++; + } + } +} + +static void +_GraalPyMem_InitHeader(mem_head_t *ptr_with_head, size_t size) +{ + ptr_with_head->size = size; + ptr_with_head->dummy = GRAALPY_MEM_HEAD_MAGIC; +} + +static void +_GraalPyMem_PoisonBlock(mem_head_t *ptr_with_head, size_t size) +{ + if (LIKELY(!_GraalPyMem_PoisonOnFreeEnabled())) { + return; + } + + memset(ptr_with_head, 0xDB, sizeof(mem_head_t) + size); + ptr_with_head->size = GRAALPY_MEM_HEAD_POISON; + ptr_with_head->dummy = GRAALPY_MEM_HEAD_POISON; +} + +static void +_GraalPyMem_FatalInvalidHeader(const char *func, void *ptr, const mem_head_t *ptr_with_head) +{ + const char *reason = (ptr_with_head->size == GRAALPY_MEM_HEAD_POISON && ptr_with_head->dummy == GRAALPY_MEM_HEAD_POISON) + ? "poisoned raw allocation header" + : "invalid raw allocation header"; + GraalPyPrivate_Log(GRAALPY_LOG_INFO, + "%s: %s for ptr=%p head=%p size=%lu dummy=0x%lx\n", + func, reason, ptr, ptr_with_head, (unsigned long) ptr_with_head->size, (unsigned long) ptr_with_head->dummy); + _GraalPyMem_LogRecentSamples(func, ptr); + Py_FatalError("invalid GraalPy raw allocation header"); +} + +static mem_head_t * +_GraalPyMem_GetValidatedHead(const char *func, void *ptr) +{ + mem_head_t *ptr_with_head = AS_MEM_HEAD(ptr); + if (UNLIKELY(ptr_with_head->dummy != GRAALPY_MEM_HEAD_MAGIC)) { + _GraalPyMem_FatalInvalidHeader(func, ptr, ptr_with_head); + } + return ptr_with_head; +} #if 0 // GraalPy change /* bpo-35053: Declare tracemalloc configuration here rather than @@ -325,7 +448,9 @@ PyMem_RawMalloc(size_t size) */ if (size > (size_t)PY_SSIZE_T_MAX) return NULL; - return _PyMem_Raw.malloc(_PyMem_Raw.ctx, size); + void *ptr = _PyMem_Raw.malloc(_PyMem_Raw.ctx, size); + _GraalPyMem_RecordSample('m', ptr, size == 0 ? 1 : size); + return ptr; } void * @@ -334,7 +459,10 @@ PyMem_RawCalloc(size_t nelem, size_t elsize) /* see PyMem_RawMalloc() */ if (elsize != 0 && nelem > (size_t)PY_SSIZE_T_MAX / elsize) return NULL; - return _PyMem_Raw.calloc(_PyMem_Raw.ctx, nelem, elsize); + void *ptr = _PyMem_Raw.calloc(_PyMem_Raw.ctx, nelem, elsize); + size_t nbytes = (nelem == 0 || elsize == 0) ? 1 : nelem * elsize; + _GraalPyMem_RecordSample('c', ptr, nbytes); + return ptr; } void* @@ -343,11 +471,14 @@ PyMem_RawRealloc(void *ptr, size_t new_size) /* see PyMem_RawMalloc() */ if (new_size > (size_t)PY_SSIZE_T_MAX) return NULL; - return _PyMem_Raw.realloc(_PyMem_Raw.ctx, ptr, new_size); + void *new_ptr = _PyMem_Raw.realloc(_PyMem_Raw.ctx, ptr, new_size); + _GraalPyMem_RecordSample('r', new_ptr, new_size == 0 ? 1 : new_size); + return new_ptr; } void PyMem_RawFree(void *ptr) { + _GraalPyMem_RecordSample('f', ptr, 0); _PyMem_Raw.free(_PyMem_Raw.ctx, ptr); } @@ -381,7 +512,7 @@ _GraalPyMem_PrepareAlloc(GraalPyMem_t *state, size_t size) state->native_memory_gc_barrier = GraalPyPrivate_GetInitialNativeMemory(); continue; } - GraalPyPrivate_Log(PY_TRUFFLE_LOG_CONFIG, + GraalPyPrivate_Log(GRAALPY_LOG_CONFIG, "%s: exceeding native_memory_gc_barrier (%lu) with allocation of size %lu, current allocated_memory: %lu\n", __func__, state->native_memory_gc_barrier, size, state->allocated_memory); @@ -401,12 +532,12 @@ _GraalPyMem_PrepareAlloc(GraalPyMem_t *state, size_t size) if (state->native_memory_gc_barrier > state->max_native_memory) { state->native_memory_gc_barrier = state->max_native_memory; } - GraalPyPrivate_Log(PY_TRUFFLE_LOG_CONFIG, + GraalPyPrivate_Log(GRAALPY_LOG_CONFIG, "%s: enlarging native_memory_gc_barrier to %lu\n", __func__, state->native_memory_gc_barrier); } else { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_INFO, + GraalPyPrivate_Log(GRAALPY_LOG_INFO, "%s: native memory exhausted while allocating %lu bytes\n", __func__, size); return 1; @@ -426,11 +557,16 @@ _GraalPyMem_RawMalloc(void *ctx, size_t size) To solve these problems, allocate an extra byte. */ if (size == 0) size = 1; - if (_GraalPyMem_PrepareAlloc((GraalPyMem_t*) ctx, size)) { + GraalPyMem_t *state = (GraalPyMem_t *)ctx; + if (_GraalPyMem_PrepareAlloc(state, size)) { return NULL; } mem_head_t *ptr_with_head = (mem_head_t *)malloc(size + sizeof(mem_head_t)); - ptr_with_head->size = size; + if (ptr_with_head == NULL) { + state->allocated_memory -= size; + return NULL; + } + _GraalPyMem_InitHeader(ptr_with_head, size); return FROM_MEM_HEAD(ptr_with_head); } @@ -450,15 +586,20 @@ _GraalPyMem_RawCalloc(void *ctx, size_t nelem, size_t elsize) elsize = 1; } size_t nbytes = nelem * elsize; - if (_GraalPyMem_PrepareAlloc((GraalPyMem_t*) ctx, nbytes)) { + GraalPyMem_t *state = (GraalPyMem_t *)ctx; + if (_GraalPyMem_PrepareAlloc(state, nbytes)) { return NULL; } /* We cannot use 'calloc' because we need to allocate following layout: [ mem_head_t ] [ e_0 ] [ e_1 ] [ e_2 ] ... [ n_nelem ] */ size_t total = nbytes + sizeof(mem_head_t); mem_head_t *ptr_with_head = (mem_head_t *)malloc(total); + if (ptr_with_head == NULL) { + state->allocated_memory -= nbytes; + return NULL; + } memset(ptr_with_head, 0, total); - ptr_with_head->size = nbytes; + _GraalPyMem_InitHeader(ptr_with_head, nbytes); return FROM_MEM_HEAD(ptr_with_head); } @@ -474,25 +615,33 @@ _GraalPyMem_RawRealloc(void *ctx, void *ptr, size_t size) size = 1; if (ptr != NULL) { - old = AS_MEM_HEAD(ptr); + old = _GraalPyMem_GetValidatedHead(__func__, ptr); old_size = old->size; } else { old = NULL; old_size = 0; } - // account for the difference in size - if (old_size >= size) { - /* In case of "shrinking", just subtract the counter but don't trigger - the Java GC. */ - state->allocated_memory -= size; - } else if (_GraalPyMem_PrepareAlloc(state, size - old_size)) { + if (old_size < size && _GraalPyMem_PrepareAlloc(state, size - old_size)) { return NULL; } mem_head_t *ptr_with_head = (mem_head_t *)realloc(old, size + sizeof(mem_head_t)); - ptr_with_head->size = size; + if (ptr_with_head == NULL) { + if (old_size < size) { + state->allocated_memory -= size - old_size; + } + return NULL; + } + + if (old_size > size) { + /* In case of "shrinking", just subtract the difference but don't + trigger the Java GC. */ + state->allocated_memory -= old_size - size; + } + + _GraalPyMem_InitHeader(ptr_with_head, size); return FROM_MEM_HEAD(ptr_with_head); } @@ -506,14 +655,15 @@ _GraalPyMem_RawFree(void *ctx, void *ptr) if (ptr == NULL) return; GraalPyMem_t *state = (GraalPyMem_t *)ctx; - mem_head_t *ptr_with_head = AS_MEM_HEAD(ptr); + mem_head_t *ptr_with_head = _GraalPyMem_GetValidatedHead(__func__, ptr); const size_t size = ptr_with_head->size; if (state->allocated_memory < size) { - GraalPyPrivate_Log(PY_TRUFFLE_LOG_INFO, + GraalPyPrivate_Log(GRAALPY_LOG_INFO, "%s: freed memory size (%lu) is larger than allocated memory size (%lu)\n", __func__, size, state->allocated_memory); state->allocated_memory = size; } state->allocated_memory -= size; + _GraalPyMem_PoisonBlock(ptr_with_head, size); free(ptr_with_head); } diff --git a/graalpython/com.oracle.graal.python.cext/src/pyhash.c b/graalpython/com.oracle.graal.python.cext/src/pyhash.c index b7ad58cf07..1d5b4c1182 100644 --- a/graalpython/com.oracle.graal.python.cext/src/pyhash.c +++ b/graalpython/com.oracle.graal.python.cext/src/pyhash.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -489,7 +489,7 @@ long _PyHASH_INF; long _PyHASH_MODULUS; long _PyHASH_IMAG; -void +Py_LOCAL_SYMBOL void initialize_hashes() { _PyHASH_INF = GraalPyPrivate_HashConstant(0); diff --git a/graalpython/com.oracle.graal.python.cext/src/pylifecycle.c b/graalpython/com.oracle.graal.python.cext/src/pylifecycle.c index 77e295c1fc..16f474b73d 100644 --- a/graalpython/com.oracle.graal.python.cext/src/pylifecycle.c +++ b/graalpython/com.oracle.graal.python.cext/src/pylifecycle.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -73,6 +73,36 @@ _Py_IsFinalizing(void) return graalpy_finalizing; } +static void +graalpy_fork_not_supported(void) +{ + PyErr_SetString(PyExc_SystemError, "fork is not supported by GraalPy"); +} + +void +PyOS_BeforeFork(void) +{ + graalpy_fork_not_supported(); +} + +void +PyOS_AfterFork_Parent(void) +{ + graalpy_fork_not_supported(); +} + +void +PyOS_AfterFork_Child(void) +{ + graalpy_fork_not_supported(); +} + +void +PyOS_AfterFork(void) +{ + PyOS_AfterFork_Child(); +} + void _Py_NO_RETURN _Py_FatalErrorFunc(const char *func, const char *msg) { const char *prefix1 = "", *prefix2 = ""; if (func) { diff --git a/graalpython/com.oracle.graal.python.cext/src/pystate.c b/graalpython/com.oracle.graal.python.cext/src/pystate.c index b54a724306..93a2faada1 100644 --- a/graalpython/com.oracle.graal.python.cext/src/pystate.c +++ b/graalpython/com.oracle.graal.python.cext/src/pystate.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2024, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2024, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2024 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -31,7 +31,6 @@ #include "capi.h" #include -extern TruffleContext* TRUFFLE_CONTEXT; static THREAD_LOCAL int graalpy_attached_thread = 0; static THREAD_LOCAL int graalpy_gilstate_counter = 0; @@ -84,9 +83,16 @@ static inline PyThreadState * _get_thread_state() { PyThreadState *ts = tstate_current; if (UNLIKELY(ts == NULL)) { - ts = GraalPyPrivate_ThreadState_Get(&tstate_current); - tstate_current = ts; + /* + * Very unlikely fallback: this can happen if another thread initializes the C API while + * the current thread is attached to Python but blocked and therefore misses eager + * initialization of its native 'tstate_current' TLS slot. + */ + ts = GraalPyPrivate_ThreadState_Get(&tstate_current); + assert(ts != NULL); + tstate_current = ts; } + assert(ts != NULL); return ts; } @@ -1416,6 +1422,7 @@ init_threadstate(PyThreadState *tstate, tstate->datastack_top = NULL; tstate->datastack_limit = NULL; tstate->what_event = -1; + graalpy_initialize_thread_state_singletons(tstate); tstate->_status.initialized = 1; } @@ -2283,22 +2290,22 @@ PyGILState_Check(void) return (tstate == gilstate_tss_get(runtime)); #else // GraalPy change - int attached = 0; /* * PyGILState_Check is allowed to be called from a new thread that didn't yet setup the GIL. - * If we don't attach the thread ourselves, the upcall will work because NFI will attach - * the thread automatically, but it won't create the context which would then break - * subsequent PyGILState_Ensure. + * We must attach it before calling into Java so the upcall has an entered polyglot context. */ - if (TRUFFLE_CONTEXT) { - if ((*TRUFFLE_CONTEXT)->getTruffleEnv(TRUFFLE_CONTEXT) == NULL) { - (*TRUFFLE_CONTEXT)->attachCurrentThread(TRUFFLE_CONTEXT); - attached = 1; + int attached = 0; + if (graalpy_attach_native_thread) { + attached = graalpy_attach_native_thread(); + if (attached == GRAALPY_ATTACH_NATIVE_FAILED) { + return 0; } + } else { + return 0; } int ret = GraalPyPrivate_GILState_Check(); - if (attached) { - (*TRUFFLE_CONTEXT)->detachCurrentThread(TRUFFLE_CONTEXT); + if (attached == GRAALPY_ATTACH_NATIVE_OWNED && graalpy_detach_native_thread) { + graalpy_detach_native_thread(); } return ret; #endif // GraalPy change @@ -2355,13 +2362,18 @@ PyGILState_Ensure(void) return has_gil ? PyGILState_LOCKED : PyGILState_UNLOCKED; #else // GraalPy change - if (TRUFFLE_CONTEXT) { - if ((*TRUFFLE_CONTEXT)->getTruffleEnv(TRUFFLE_CONTEXT) == NULL) { - (*TRUFFLE_CONTEXT)->attachCurrentThread(TRUFFLE_CONTEXT); + if (!graalpy_attach_native_thread) { + Py_FatalError("PyGILState_Ensure called before GraalPy C API initialization"); + } + if (!graalpy_attached_thread) { + int attached = graalpy_attach_native_thread(); + if (attached == GRAALPY_ATTACH_NATIVE_FAILED) { + Py_FatalError("Could not attach native thread to the polyglot context"); + } else if (attached == GRAALPY_ATTACH_NATIVE_OWNED) { graalpy_attached_thread = 1; } - graalpy_gilstate_counter++; } + graalpy_gilstate_counter++; return GraalPyPrivate_GILState_Ensure() ? PyGILState_UNLOCKED : PyGILState_LOCKED; #endif // GraalPy change } @@ -2421,20 +2433,20 @@ PyGILState_Release(PyGILState_STATE oldstate) if (oldstate == PyGILState_UNLOCKED) { GraalPyPrivate_GILState_Release(); } - if (TRUFFLE_CONTEXT) { - graalpy_gilstate_counter--; - if (graalpy_gilstate_counter == 0 && graalpy_attached_thread) { - GraalPyPrivate_BeforeThreadDetach(); - (*TRUFFLE_CONTEXT)->detachCurrentThread(TRUFFLE_CONTEXT); - graalpy_attached_thread = 0; - /* - * The thread state on the Java-side is cleared in GraalPyPrivate_BeforeThreadDetach. - * As part of that the tstate_current pointer should have been set to NULL to make - * sure to fetch a fresh pointer the next time we attach. Just to be sure, we clear - * it here too: - */ - tstate_current = NULL; + graalpy_gilstate_counter--; + if (graalpy_gilstate_counter == 0 && graalpy_attached_thread) { + GraalPyPrivate_BeforeThreadDetach(); + if (graalpy_detach_native_thread) { + graalpy_detach_native_thread(); } + graalpy_attached_thread = 0; + /* + * The thread state on the Java-side is cleared in GraalPyPrivate_BeforeThreadDetach. + * As part of that the tstate_current pointer should have been set to NULL to make + * sure to fetch a fresh pointer the next time we attach. Just to be sure, we clear + * it here too: + */ + tstate_current = NULL; } #endif // GraalPy change } diff --git a/graalpython/com.oracle.graal.python.cext/src/sysmodule.c b/graalpython/com.oracle.graal.python.cext/src/sysmodule.c index 3796e7fb4d..79b28f3aaa 100644 --- a/graalpython/com.oracle.graal.python.cext/src/sysmodule.c +++ b/graalpython/com.oracle.graal.python.cext/src/sysmodule.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,6 +40,9 @@ */ #include "capi.h" +#include "pycore_pyerrors.h" // _PyErr_GetRaisedException() +#include "pycore_pystate.h" // _PyThreadState_GET() + int PySys_Audit(const char *event, const char *argFormat, ...) { // ignore for now return 0; @@ -84,6 +87,35 @@ PySys_WriteStderr(const char *format, ...) va_end(va); } +static void +sys_format(int key, FILE *fp, const char *format, va_list va) +{ + PyObject *message; // GraalPy change + const char *utf8; + PyThreadState *tstate = _PyThreadState_GET(); + + PyObject *exc = _PyErr_GetRaisedException(tstate); + message = PyUnicode_FromFormatV(format, va); + if (message != NULL) { +#if 0 // GraalPy change + file = _PySys_GetRequiredAttr(key); + if (sys_pyfile_write_unicode(message, file) != 0) { +#endif // GraalPy change + // GraalPy change: different implementation + if (GraalPyPrivate_Sys_PyFileWriteUnicode(key, message) != 0) { + _PyErr_Clear(tstate); + utf8 = PyUnicode_AsUTF8(message); + if (utf8 != NULL) + fputs(utf8, fp); + } +#if 0 // GraalPy change + Py_XDECREF(file); +#endif // GraalPy change + Py_DECREF(message); + } + _PyErr_SetRaisedException(tstate, exc); +} + void PySys_FormatStdout(const char *format, ...) { @@ -91,7 +123,7 @@ PySys_FormatStdout(const char *format, ...) va_start(va, format); // GraalPy change: different implementation - GraalPyPrivate_Sys_FormatStd(0, format, &va); + sys_format(0, stdout, format, va); va_end(va); } @@ -102,6 +134,6 @@ PySys_FormatStderr(const char *format, ...) va_start(va, format); // GraalPy change: different implementation - GraalPyPrivate_Sys_FormatStd(1, format, &va); + sys_format(1, stderr, format, va); va_end(va); } diff --git a/graalpython/com.oracle.graal.python.cext/src/tupleobject.c b/graalpython/com.oracle.graal.python.cext/src/tupleobject.c index a9fd4f2a7b..5b4730b249 100644 --- a/graalpython/com.oracle.graal.python.cext/src/tupleobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/tupleobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -17,9 +17,6 @@ #endif // GraalPy change #include "pycore_object.h" // _PyObject_GC_TRACK(), _Py_FatalRefcountError() -// GraalPy change -void GraalPyPrivate_Tuple_Dealloc(PyTupleObject* self); - #if 0 // GraalPy change /*[clinic input] class tuple "PyTupleObject *" "&PyTuple_Type" @@ -108,6 +105,66 @@ PyTuple_Size(PyObject *op) } #endif // GraalPy change +/* Allocate an uninitialized tuple object. Before making it public, following + steps must be done: + + - Initialize its items. + - Call _PyObject_GC_TRACK() on it. + + GraalPy change: unlike CPython, this does not use the tuple freelist. +*/ +static PyTupleObject * +tuple_alloc(Py_ssize_t size) +{ + if (size < 0) { + PyErr_BadInternalCall(); + return NULL; + } + /* Check for overflow */ + if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - (sizeof(PyTupleObject) - + sizeof(PyObject *))) / sizeof(PyObject *)) { + return (PyTupleObject *)PyErr_NoMemory(); + } + PyTupleObject *op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size); + if (op == NULL) { + return NULL; + } + return op; +} + +static inline PyObject * +tuple_get_empty(void) +{ + /* + * GraalPy change: allocate a native empty tuple instead of returning CPython's static + * singleton, so PyTuple_New consistently returns native tuples. + */ + PyTupleObject *op = tuple_alloc(0); + if (op == NULL) { + return NULL; + } + _PyObject_GC_TRACK(op); + return (PyObject *)op; +} + +PyObject * +PyTuple_New(Py_ssize_t size) +{ + PyTupleObject *op; + if (size == 0) { + return tuple_get_empty(); + } + op = tuple_alloc(size); + if (op == NULL) { + return NULL; + } + for (Py_ssize_t i = 0; i < size; i++) { + op->ob_item[i] = NULL; + } + _PyObject_GC_TRACK(op); + return (PyObject *)op; +} + PyObject * PyTuple_GetItem(PyObject *op, Py_ssize_t i) { // GraalPy change: different implementation @@ -203,13 +260,13 @@ PyTuple_Pack(Py_ssize_t n, ...) return result; } -#if 0 // GraalPy change /* Methods */ static void tupledealloc(PyTupleObject *op) { +#if 0 // GraalPy change if (Py_SIZE(op) == 0) { /* The empty tuple is statically allocated. */ if (op == &_Py_SINGLETON(tuple_empty)) { @@ -224,6 +281,7 @@ tupledealloc(PyTupleObject *op) assert(!PyTuple_CheckExact(op)); #endif } +#endif // GraalPy change PyObject_GC_UnTrack(op); Py_TRASHCAN_BEGIN(op, tupledealloc) @@ -233,13 +291,17 @@ tupledealloc(PyTupleObject *op) Py_XDECREF(op->ob_item[i]); } // This will abort on the empty singleton (if there is one). +#if 0 // GraalPy change if (!maybe_freelist_push(op)) { Py_TYPE(op)->tp_free((PyObject *)op); } +#endif // GraalPy change + Py_TYPE(op)->tp_free((PyObject *)op); Py_TRASHCAN_END } +#if 0 // GraalPy change static PyObject * tuplerepr(PyTupleObject *v) { @@ -711,6 +773,7 @@ tuplerichcompare(PyObject *v, PyObject *w, int op) /* Compare the final item again using the proper operator */ return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op); } +#endif // GraalPy change static PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable); @@ -737,13 +800,43 @@ tuple_new_impl(PyTypeObject *type, PyObject *iterable) return tuple_subtype_new(type, iterable); if (iterable == NULL) { +#if 0 // GraalPy change return tuple_get_empty(); +#endif // GraalPy change + return PyTuple_New(0); } else { return PySequence_Tuple(iterable); } } +// GraalPy change: imported from 'clinit/tupleobject.c.h' +static PyObject * +tuple_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) +{ + PyObject *return_value = NULL; + PyTypeObject *base_tp = &PyTuple_Type; + PyObject *iterable = NULL; + + if ((type == base_tp || type->tp_init == base_tp->tp_init) && + !_PyArg_NoKeywords("tuple", kwargs)) { + goto exit; + } + if (!_PyArg_CheckPositional("tuple", PyTuple_GET_SIZE(args), 0, 1)) { + goto exit; + } + if (PyTuple_GET_SIZE(args) < 1) { + goto skip_optional; + } + iterable = PyTuple_GET_ITEM(args, 0); + skip_optional: + return_value = tuple_new_impl(type, iterable); + + exit: + return return_value; +} + +#if 0 // GraalPy change static PyObject * tuple_vectorcall(PyObject *type, PyObject * const*args, size_t nargsf, PyObject *kwnames) @@ -767,37 +860,49 @@ tuple_vectorcall(PyObject *type, PyObject * const*args, #endif // GraalPy change -// GraalPy change -PyObject* GraalPyPrivate_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems); - -PyAPI_FUNC(PyObject *) // GraalPy change: export for downcall, rename -GraalPyPrivate_Tuple_SubtypeNew(PyTypeObject *type, PyObject *iterable) +static PyObject * +tuple_subtype_new(PyTypeObject *type, PyObject *iterable) { - // GraalPy change: different implementation PyObject *tmp, *newobj, *item; Py_ssize_t i, n; assert(PyType_IsSubtype(type, &PyTuple_Type)); - tmp = iterable == NULL ? PyTuple_New(0) : PySequence_Tuple(iterable); + // tuple subclasses must implement the GC protocol + assert(_PyType_IS_GC(type)); + + tmp = tuple_new_impl(&PyTuple_Type, iterable); if (tmp == NULL) return NULL; assert(PyTuple_Check(tmp)); - n = PyTuple_GET_SIZE(tmp); - - /* GraalPy note: we cannot call type->tp_alloc here because managed subtypes don't inherit tp_alloc but get a generic one. - * In CPython tuple uses the generic one to begin with, so they don't have this problem - */ - newobj = GraalPyPrivate_Tuple_Alloc(type, n); + /* This may allocate an empty tuple that is not the global one. */ + newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp)); if (newobj == NULL) { + Py_DECREF(tmp); return NULL; } + // GraalPy change + PyObject **src_arr = _PyTuple_ITEMS(tmp); + PyObject **arr = _PyTuple_ITEMS(newobj); for (i = 0; i < n; i++) { +#if 0 // GraalPy change item = PyTuple_GET_ITEM(tmp, i); - Py_INCREF(item); - ((PyTupleObject*) newobj)->ob_item[i] = Py_NewRef(item); // PyTuple_SETITEM + PyTuple_SET_ITEM(newobj, i, Py_NewRef(item)); +#endif // GraalPy change + arr[i] = Py_NewRef(src_arr[i]); } Py_DECREF(tmp); - return (PyObject*) newobj; + + // Don't track if a subclass tp_alloc is PyType_GenericAlloc() + if (!_PyObject_GC_IS_TRACKED(newobj)) { + _PyObject_GC_TRACK(newobj); + } + return newobj; +} + +GraalPy_CAPI_HELPER_SYMBOL PyObject * // GraalPy change: helper-table entry for downcall, rename +GraalPyPrivate_Tuple_SubtypeNew(PyTypeObject *type, PyObject *iterable) +{ + return tuple_subtype_new(type, iterable); } #if 0 // GraalPy change @@ -900,7 +1005,7 @@ PyTypeObject PyTuple_Type = { "tuple", sizeof(PyTupleObject) - sizeof(PyObject *), sizeof(PyObject *), - (destructor)GraalPyPrivate_Tuple_Dealloc, /* tp_dealloc */ // GraalPy change: different function + (destructor)tupledealloc, /* tp_dealloc */ 0, /* tp_vectorcall_offset */ 0, /* tp_getattr */ 0, /* tp_setattr */ @@ -934,9 +1039,9 @@ PyTypeObject PyTuple_Type = { 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ - GraalPyPrivate_Tuple_Alloc, /* tp_alloc */ // GraalPy change - 0, /* tp_new */ // GraalPy change: nulled - GraalPyPrivate_Object_GC_Del, /* tp_free */ // GraalPy change: different function + 0, /* tp_alloc */ + tuple_new, /* tp_new */ + PyObject_GC_Del, /* tp_free */ #if 0 // GraalPy change .tp_vectorcall = tuple_vectorcall, #endif // GraalPy change @@ -1305,67 +1410,6 @@ _PyTuple_DebugMallocStats(FILE *out) #undef FREELIST_FINALIZED #endif // GraalPy change -// GraalPy additions -PyObject* GraalPyPrivate_Tuple_Alloc(PyTypeObject* type, Py_ssize_t nitems) { - /* - * TODO(fa): For 'PyVarObjects' (i.e. 'nitems > 0') we increase the size by 'sizeof(void *)' - * because this additional pointer can then be used as pointer to the element array. - * CPython usually embeds the array in the struct but Sulong doesn't currently support that. - * So we allocate space for the additional array pointer. - * Also consider any 'PyVarObject' (in particular 'PyTupleObject') if this is fixed. - * - * This function is mostly an inlined copy-paste of PyType_GenericAlloc, with different size - * and added initialization of ob_item - */ - PyObject *obj; - const size_t size = _PyObject_VAR_SIZE(type, nitems+1) + sizeof(PyObject **); - /* note that we need to add one, for the sentinel */ - - const size_t presize = _PyType_PreHeaderSize(type); - char *alloc = PyObject_Malloc(size + presize); - if (alloc == NULL) { - return PyErr_NoMemory(); - } - obj = (PyObject *)(alloc + presize); - if (presize) { - // GraalPy change: different header layout, no GC link - ((PyObject **)alloc)[0] = NULL; - } - memset(obj, '\0', size); - - if (type->tp_itemsize == 0) { - _PyObject_Init(obj, type); - } - else { - _PyObject_InitVar((PyVarObject *)obj, type, nitems); - } - - if (_PyType_IS_GC(type)) { - _PyObject_GC_TRACK(obj); - } - - ((PyTupleObject*)obj)->ob_item = (PyObject **) ((char *)obj + offsetof(PyTupleObject, ob_item) + sizeof(PyObject **)); - - return obj; -} - -void GraalPyPrivate_Tuple_Dealloc(PyTupleObject* self) { - PyObject_GC_UnTrack(self); - if (points_to_py_handle_space(self)) { - return; - } - Py_TRASHCAN_BEGIN(self, GraalPyPrivate_Tuple_Dealloc) - Py_ssize_t len = PyTuple_GET_SIZE(self); - if (len > 0) { - Py_ssize_t i = len; - while (--i >= 0) { - Py_XDECREF(self->ob_item[i]); - } - } - Py_TYPE(self)->tp_free((PyObject *)self); - Py_TRASHCAN_END -} - PyObject ** GraalPyTuple_ITEMS(PyObject *op) { diff --git a/graalpython/com.oracle.graal.python.cext/src/typeobject.c b/graalpython/com.oracle.graal.python.cext/src/typeobject.c index c7cad805e8..c15d299f18 100644 --- a/graalpython/com.oracle.graal.python.cext/src/typeobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/typeobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2022 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -1803,10 +1803,10 @@ traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg) return 0; } -/* GraalPy change: replaced 'static' with 'PyAPI_FUNC' and renamed because we lookup the - * symbol in Java to use it if a type receives 'toNative'. +/* GraalPy change: renamed and exposed through the native helper table because Java uses + * it if a type receives 'toNative'. */ -PyAPI_FUNC(int) +GraalPy_CAPI_HELPER_SYMBOL int GraalPyPrivate_SubtypeTraverse(PyObject *self, visitproc visit, void *arg) { PyTypeObject *type, *base; @@ -5038,20 +5038,28 @@ type_setattro(PyTypeObject *type, PyObject *name, PyObject *value) extern void _PyDictKeys_DecRef(PyDictKeysObject *keys); +#endif // GraalPy change static void type_dealloc_common(PyTypeObject *type) { +#if 0 // GraalPy change PyObject *bases = lookup_tp_bases(type); if (bases != NULL) { PyObject *exc = PyErr_GetRaisedException(); remove_all_subclasses(type, bases); PyErr_SetRaisedException(exc); } +#endif // GraalPy change + + // GraalPy change + GraalPyPrivate_Type_NotifyDealloc(type, type->tp_version_tag); + type->tp_version_tag = 0; } +#if 0 // GraalPy change static void clear_static_tp_subclasses(PyTypeObject *type) { @@ -5138,9 +5146,7 @@ type_dealloc(PyTypeObject *type) _PyObject_GC_UNTRACK(type); -#if 0 // GraalPy change type_dealloc_common(type); -#endif // GraalPy change // PyObject_ClearWeakRefs() raises an exception if Py_REFCNT() != 0 assert(Py_REFCNT(type) == 0); @@ -5418,7 +5424,7 @@ type_is_gc(PyTypeObject *type) * just test for 'points_to_py_handle_space' but this is not applicable for * 'PyTypeObject' because there we really allocate and fill a native * mirror. */ - return type->tp_flags & Py_TPFLAGS_HEAPTYPE && Py_REFCNT(type) != IMMORTAL_REFCNT; + return type->tp_flags & Py_TPFLAGS_HEAPTYPE && Py_REFCNT(type) != _Py_IMMORTAL_REFCNT; } @@ -6712,7 +6718,6 @@ type_add_method(PyTypeObject *type, PyMethodDef *meth) meth->ml_name, meth->ml_meth, meth->ml_flags, - get_method_flags_wrapper(meth->ml_flags), meth->ml_doc); } @@ -7316,6 +7321,9 @@ type_ready_mro(PyTypeObject *type) } #else // GraalPy change PyObject* mro = GraalPyPrivate_Compute_Mro(type, type->tp_name); + if (mro == NULL) { + return -1; + } type->tp_mro = mro; #endif // GraalPy change return 0; @@ -7582,6 +7590,10 @@ type_ready(PyTypeObject *type, int rerunbuiltin) #endif #endif // GraalPy change + /* GraalPy change: We use 'tp_version_tag' to store an index for a fast lookup table. To avoid accidentally + incorrect associations, we clear the field in the very beginning. */ + type->tp_version_tag = 0; + /* GraalPy change: IMPORTANT: This is a Truffle-specific statement. Since the refcnt for the type is currently 0 and we will create several references to this object that will be collected during the execution of this method, we need to keep it alive. */ @@ -7650,6 +7662,9 @@ type_ready(PyTypeObject *type, int rerunbuiltin) assert(_PyType_CheckConsistency(type)); + // GraalPy change + GraalPyPrivate_NotifyTypeReady(type); + // GraalPy change: for reason, see first call to Py_INCREF in this function Py_DECREF(type); return 0; diff --git a/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c b/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c index 89652cf67b..07b67dff80 100644 --- a/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c +++ b/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2018, 2025, Oracle and/or its affiliates. +/* Copyright (c) 2018, 2026, Oracle and/or its affiliates. * Copyright (C) 1996-2020 Python Software Foundation * * Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -127,6 +127,33 @@ extern "C" { # define _PyUnicode_CHECK(op) PyUnicode_Check(op) #endif +static inline Py_ssize_t * +GraalPyPrivate_Unicode_LengthPtr(PyObject *op) +{ + if (points_to_py_handle_space(op)) { + return &((GraalPyUnicodeObject *) pointer_to_stub(op))->length; + } + return &_PyASCIIObject_CAST(op)->length; +} + +static inline Py_hash_t * +GraalPyPrivate_Unicode_HashPtr(PyObject *op) +{ + if (points_to_py_handle_space(op)) { + return &((GraalPyUnicodeObject *) pointer_to_stub(op))->hash; + } + return &_PyASCIIObject_CAST(op)->hash; +} + +static inline void ** +GraalPyPrivate_Unicode_DataPtr(PyObject *op) +{ + if (points_to_py_handle_space(op)) { + return &((GraalPyUnicodeObject *) pointer_to_stub(op))->data; + } + return &_PyUnicodeObject_CAST(op)->data.any; +} + #define _PyUnicode_UTF8(op) \ (_PyCompactUnicodeObject_CAST(op)->utf8) #define PyUnicode_UTF8(op) \ @@ -143,19 +170,19 @@ extern "C" { _PyUnicode_UTF8_LENGTH(op)) #define _PyUnicode_LENGTH(op) \ - (_PyASCIIObject_CAST(op)->length) + (*GraalPyPrivate_Unicode_LengthPtr(_PyObject_CAST(op))) #define _PyUnicode_STATE(op) \ (_PyASCIIObject_CAST(op)->state) #define _PyUnicode_HASH(op) \ - (_PyASCIIObject_CAST(op)->hash) + (*GraalPyPrivate_Unicode_HashPtr(_PyObject_CAST(op))) #define _PyUnicode_KIND(op) \ (assert(_PyUnicode_CHECK(op)), \ - _PyASCIIObject_CAST(op)->state.kind) + PyUnicode_KIND(op)) #define _PyUnicode_GET_LENGTH(op) \ (assert(_PyUnicode_CHECK(op)), \ - _PyASCIIObject_CAST(op)->length) + PyUnicode_GET_LENGTH(op)) #define _PyUnicode_DATA_ANY(op) \ - (_PyUnicodeObject_CAST(op)->data.any) + (*GraalPyPrivate_Unicode_DataPtr(_PyObject_CAST(op))) #define _PyUnicode_SHARE_UTF8(op) \ (assert(_PyUnicode_CHECK(op)), \ @@ -666,12 +693,17 @@ unicode_check_encoding_errors(const char *encoding, const char *errors) int _PyUnicode_CheckConsistency(PyObject *op, int check_content) { + // GraalPy change: do not access managed unicode objects + if (points_to_py_handle_space(op)) + return 1; + #define CHECK(expr) \ do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0) assert(op != NULL); CHECK(PyUnicode_Check(op)); +#if 0 // GraalPy change (different internal representation) PyASCIIObject *ascii = _PyASCIIObject_CAST(op); int kind = ascii->state.kind; @@ -778,6 +810,7 @@ _PyUnicode_CheckConsistency(PyObject *op, int check_content) Py_UNREACHABLE(); } #endif +#endif // GraalPy change return 1; @@ -1352,22 +1385,24 @@ PyObject * PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar) { // GraalPy change: different implementation - /* add one to size for the null character */ + if (size < 0) { + PyErr_SetString(PyExc_SystemError, + "Negative size passed to PyUnicode_New"); + return NULL; + } if (maxchar < 128) { - /* We intentionally use 'size' (which is one element less than the allocated array) - * because interop users should not see the null character. */ - return GraalPyPrivate_Unicode_New((Py_UCS1 *) calloc(size + 1, PyUnicode_1BYTE_KIND), size, PyUnicode_1BYTE_KIND, 1); + return GraalPyPrivate_Unicode_New(size, PyUnicode_1BYTE_KIND, 1); } else if (maxchar < 256) { - return GraalPyPrivate_Unicode_New((Py_UCS1 *) calloc(size + 1, PyUnicode_1BYTE_KIND), size, PyUnicode_1BYTE_KIND, 0); + return GraalPyPrivate_Unicode_New(size, PyUnicode_1BYTE_KIND, 0); } else if (maxchar < 65536) { - return GraalPyPrivate_Unicode_New((Py_UCS2 *) calloc(size + 1, PyUnicode_2BYTE_KIND), size, PyUnicode_2BYTE_KIND, 0); + return GraalPyPrivate_Unicode_New(size, PyUnicode_2BYTE_KIND, 0); } else { if (maxchar > MAX_UNICODE) { PyErr_SetString(PyExc_SystemError, "invalid maximum character passed to PyUnicode_New"); return NULL; } - return GraalPyPrivate_Unicode_New((Py_UCS4 *) calloc(size + 1, PyUnicode_4BYTE_KIND), size, PyUnicode_4BYTE_KIND, 0); + return GraalPyPrivate_Unicode_New(size, PyUnicode_4BYTE_KIND, 0); } /* should never be reached */ return NULL; @@ -1670,8 +1705,8 @@ find_maxchar_surrogates(const wchar_t *begin, const wchar_t *end, return 0; } -// GraalPy change: export -PyAPI_FUNC(void) +// GraalPy change: hidden for capi.c +Py_LOCAL_SYMBOL void unicode_dealloc(PyObject *unicode) { #ifdef Py_DEBUG @@ -12823,7 +12858,9 @@ _PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer, if (len == -1) len = strlen(ascii); +#if 0 // GraalPy change assert(ucs1lib_find_max_char((const Py_UCS1*)ascii, (const Py_UCS1*)ascii + len) < 128); +#endif // GraalPy change if (writer->buffer == NULL && !writer->overallocate) { PyObject *str; @@ -14160,7 +14197,7 @@ unicode_new_impl(PyTypeObject *type, PyObject *x, const char *encoding, } #endif // GraalPy change -PyAPI_FUNC(PyObject *) // GraalPy change: export for downcall, rename +GraalPy_CAPI_HELPER_SYMBOL PyObject * // GraalPy change: helper-table entry for downcall, rename GraalPyPrivate_Unicode_SubtypeNew(PyTypeObject *type, PyObject *unicode) { PyObject *self; @@ -14186,7 +14223,7 @@ GraalPyPrivate_Unicode_SubtypeNew(PyTypeObject *type, PyObject *unicode) _PyUnicode_STATE(self).kind = kind; _PyUnicode_STATE(self).compact = 0; // GraalPy change - _PyUnicode_STATE(self).ascii = GET_SLOT_SPECIAL(unicode, PyASCIIObject, state_ascii, state.ascii); + _PyUnicode_STATE(self).ascii = PyUnicode_IS_ASCII(unicode); _PyUnicode_STATE(self).statically_allocated = 0; _PyUnicode_UTF8_LENGTH(self) = 0; _PyUnicode_UTF8(self) = NULL; @@ -14818,8 +14855,8 @@ unicode_ascii_iter_next(unicodeiterobject *it) Py_UCS1 chr = (Py_UCS1)PyUnicode_READ(PyUnicode_1BYTE_KIND, data, it->it_index); it->it_index++; - PyObject *item = (PyObject*)&_Py_SINGLETON(strings).ascii[chr]; - return Py_NewRef(item); + char ch = (char)chr; + return PyUnicode_FromStringAndSize(&ch, 1); } it->it_seq = NULL; Py_DECREF(seq); @@ -15234,28 +15271,129 @@ PyInit__string(void) #endif // GraalPy change // GraalPy additions +/* Keep in sync with CApiTransitions.encodeGraalPyUnicodeObjectAscii. */ +static inline uint64_t +GraalPyUnicodeObject_EncodeAscii(unsigned int is_ascii) +{ + return is_ascii ? GRAALPY_UNICODE_IS_ASCII_FLAG : 0; +} + +/* Keep in sync with CApiTransitions.encodeGraalPyUnicodeObjectInterned. */ +static inline uint64_t +GraalPyUnicodeObject_EncodeInterned(unsigned int interned) +{ + return (uint64_t) interned << GRAALPY_UNICODE_INTERN_STATE_SHIFT; +} + +/* Keep in sync with CApiTransitions.createGraalPyUnicodeObjectState. */ +static inline uint64_t +GraalPyUnicodeObject_CreateState(int kind, unsigned int is_ascii, unsigned int interned) +{ + return kind | GraalPyUnicodeObject_EncodeAscii(is_ascii) | GraalPyUnicodeObject_EncodeInterned(interned); +} + +/* Keep in sync with CApiTransitions.getGraalPyUnicodeObjectInternedFromState. */ +static inline unsigned int +GraalPyUnicodeObject_GetInternedFromState(uint64_t state) +{ + return (state & GRAALPY_UNICODE_INTERN_STATE_MASK) >> GRAALPY_UNICODE_INTERN_STATE_SHIFT; +} + +/* Keep in sync with CApiTransitions.updateGraalPyUnicodeObjectInterned. */ +static inline uint64_t +GraalPyUnicodeObject_UpdateInterned(uint64_t state, unsigned int interned) +{ + return (state & ~GRAALPY_UNICODE_INTERN_STATE_MASK) | GraalPyUnicodeObject_EncodeInterned(interned); +} + +/* Keep in sync with CApiTransitions.isGraalPyUnicodeObjectAsciiFromState. */ +static inline unsigned int +GraalPyUnicodeObject_IsAsciiFromState(uint64_t state) +{ + return (state & GRAALPY_UNICODE_IS_ASCII_FLAG) != 0; +} + +/* Keep in sync with CApiTransitions.getGraalPyUnicodeObjectKindFromState. */ +static inline int +GraalPyUnicodeObject_GetKindFromState(uint64_t state) +{ + return state & GRAALPY_UNICODE_KIND_MASK; +} + +/* Keep in sync with CApiTransitions.getGraalPyUnicodeObjectInternedFromState. */ +static inline unsigned int +GraalPyUnicodeObject_GetInterned(GraalPyUnicodeObject *unicode) +{ + return GraalPyUnicodeObject_GetInternedFromState(unicode->state); +} + +/* Keep in sync with CApiTransitions.setGraalPyUnicodeObjectInterned. */ +static inline void +GraalPyUnicodeObject_SetInterned(GraalPyUnicodeObject *unicode, unsigned int interned) +{ + unicode->state = GraalPyUnicodeObject_UpdateInterned(unicode->state, interned); +} + +/* Keep in sync with CApiTransitions.isGraalPyUnicodeObjectAsciiFromState. */ +static inline unsigned int +GraalPyUnicodeObject_IsAscii(GraalPyUnicodeObject *unicode) +{ + return GraalPyUnicodeObject_IsAsciiFromState(unicode->state); +} + +/* Keep in sync with CApiTransitions.getGraalPyUnicodeObjectKind. */ +static inline int +GraalPyUnicodeObject_GetKind(GraalPyUnicodeObject *unicode) +{ + return GraalPyUnicodeObject_GetKindFromState(unicode->state); +} + unsigned int GraalPyUnicode_CHECK_INTERNED(PyObject *op) { - return GET_SLOT_SPECIAL(op, PyASCIIObject, state_interned, state.interned); + if (points_to_py_handle_space(op)) { + GraalPyUnicodeObject *unicode = (GraalPyUnicodeObject *) pointer_to_stub(op); + unsigned int interned = GraalPyUnicodeObject_GetInterned(unicode); + if (interned == GRAALPY_UNICODE_INTERN_STATE_UNDETERMINED) { + interned = GraalPyPrivate_Unicode_CheckInterned(op) ? GRAALPY_UNICODE_INTERN_STATE_INTERNED : GRAALPY_UNICODE_INTERN_STATE_NOT_INTERNED; + GraalPyUnicodeObject_SetInterned(unicode, interned); + } + return interned == GRAALPY_UNICODE_INTERN_STATE_INTERNED ? SSTATE_INTERNED_MORTAL : SSTATE_NOT_INTERNED; + } + return _PyASCIIObject_CAST(op)->state.interned; } Py_ssize_t GraalPyUnicode_GET_LENGTH(PyObject* op) { - return GraalPyPrivate_GET_PyASCIIObject_length(op); + if (points_to_py_handle_space(op)) { + return ((GraalPyUnicodeObject *) pointer_to_stub(op))->length; + } + return _PyASCIIObject_CAST(op)->length; } unsigned int GraalPyUnicode_IS_ASCII(PyObject* op) { - return GET_SLOT_SPECIAL(op, PyASCIIObject, state_ascii, state.ascii); + if (points_to_py_handle_space(op)) { + return GraalPyUnicodeObject_IsAscii((GraalPyUnicodeObject *) pointer_to_stub(op)); + } + return _PyASCIIObject_CAST(op)->state.ascii; } unsigned int GraalPyUnicode_IS_COMPACT(PyObject* op) { - return GET_SLOT_SPECIAL(op, PyASCIIObject, state_compact, state.compact); + if (points_to_py_handle_space(op)) { + return 0; + } + return _PyASCIIObject_CAST(op)->state.compact; } int GraalPyUnicode_KIND(PyObject* op) { - return GET_SLOT_SPECIAL(op, PyASCIIObject, state_kind, state.kind); + if (points_to_py_handle_space(op)) { + return GraalPyUnicodeObject_GetKind((GraalPyUnicodeObject *) pointer_to_stub(op)); + } + return _PyASCIIObject_CAST(op)->state.kind; } void* GraalPyUnicode_NONCOMPACT_DATA(PyObject* op) { - return GET_SLOT_SPECIAL(op, PyUnicodeObject, data, data.any); + if (points_to_py_handle_space(op)) { + return ((GraalPyUnicodeObject *) pointer_to_stub(op))->data; + } + return _PyUnicodeObject_CAST(op)->data.any; } #ifdef __cplusplus diff --git a/graalpython/com.oracle.graal.python.frozen/freeze_modules.py b/graalpython/com.oracle.graal.python.frozen/freeze_modules.py index ef04b9176e..929029f5b8 100644 --- a/graalpython/com.oracle.graal.python.frozen/freeze_modules.py +++ b/graalpython/com.oracle.graal.python.frozen/freeze_modules.py @@ -1,4 +1,4 @@ -# Copyright (c) 2021, 2025, Oracle and/or its affiliates. +# Copyright (c) 2021, 2026, Oracle and/or its affiliates. # Copyright (C) 1996-2020 Python Software Foundation # # Licensed under the PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 @@ -13,8 +13,8 @@ import posixpath import shutil import sys -from _sha256 import sha256 from collections import namedtuple +from io import StringIO FROZEN_ONLY = os.path.join(os.path.dirname(__file__), "flag.py") @@ -44,7 +44,9 @@ ('stdlib - startup, without site (python -S)', [ 'abc', 'codecs', - '', + # GraalPy change: don't freeze all the encodings, we have our own intrinsified encodings + '', + 'encodings.aliases', 'io', ]), ('stdlib - startup, with site', [ @@ -52,9 +54,10 @@ '_weakrefset', 'types', 'enum', - 'sre_constants', - 'sre_parse', - 'sre_compile', + # GraalPy change: don't freeze these, they are deprecated, CPython probably just forgot to remove them from here + # 'sre_constants', + # 'sre_parse', + # 'sre_compile', 'operator', 'keyword', 'heapq', @@ -109,9 +112,7 @@ def add_graalpython_core(): l = [] l.append("polyglot.arrow : polyglot.arrow = " + os.path.join(lib_graalpython, "modules/_polyglot_arrow.py")) for name in [ - "modules/_sysconfigdata", "modules/_polyglot", - "modules/_polyglot_datetime", "modules/_polyglot_time", ]: modname = os.path.basename(name) @@ -121,11 +122,8 @@ def add_graalpython_core(): "__graalpython__", "_sre", "_sysconfig", - "_weakref", - "builtins", "java", "pip_hook", - "unicodedata", "_nt", ]: modname = f"graalpy.{os.path.basename(name)}" @@ -372,7 +370,6 @@ def summarize(self): 'ispkg': self.ispkg, 'source': source, 'frozen': os.path.basename(self.frozenfile), - 'checksum': _get_checksum(self.frozenfile), } @@ -387,14 +384,6 @@ def _iter_sources(modules): ####################################### # generic helpers -def _get_checksum(filename): - with open(filename, "rb") as infile: - contents = infile.read() - m = sha256() - m.update(contents) - return m.hexdigest() - - def resolve_modules(modname, pyfile=None): if modname.startswith('<') and modname.endswith('>'): if pyfile: @@ -503,7 +492,7 @@ def lower_camel_case(str): # write frozen files FROZEN_MODULES_HEADER = """/* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -544,15 +533,18 @@ def lower_camel_case(str): */ package com.oracle.graal.python.builtins.objects.module; -import com.oracle.graal.python.builtins.PythonOS; +import com.oracle.graal.python.PythonLanguage; +import com.oracle.graal.python.annotations.PythonOS; +/** GENERATED BY graalpython/com.oracle.graal.python.frozen/freeze_modules.py */ public final class FrozenModules {""" def freeze_module(src): with open(src.pyfile, "r", encoding="utf-8") as src_file, open(src.frozenfile, "wb") as binary_file: code_obj = compile(src_file.read(), f"", "exec") - marshal.dump(code_obj, binary_file) + # GraalPy note: we don't use marshal here, we just dump the co_code which implicitly marshals the code unit + binary_file.write(code_obj.co_code) def write_frozen_modules_map(out_file, modules): @@ -582,7 +574,7 @@ def write_frozen_lookup(out_file, modules): ) elif module.name == "os.path": # Special case for os.path out_file.write(u' case "os.path":\n') - out_file.write(u' return PythonOS.getPythonOS() != PythonOS.PLATFORM_WIN32 ? Map.POSIXPATH : Map.NTPATH;\n') + out_file.write(u' return PythonLanguage.getPythonOS() != PythonOS.PLATFORM_WIN32 ? Map.POSIXPATH : Map.NTPATH;\n') else: out_file.write(f' case "{module.name}":\n') out_file.write(f" return Map.{module.symbol};\n") @@ -604,28 +596,34 @@ def write_frozen_module_file(file, modules): linesep = os.linesep else: linesep = "\n" - stat_result = os.stat(file) - atime, mtime = stat_result.st_atime, stat_result.st_mtime else: linesep = os.linesep content = None + + # Generate content in memory so we can compare with existing content and avoid + # rewriting unchanged files (e.g. in case of a read-only source filesystem). + + buf = StringIO(newline=linesep) + buf.write(FROZEN_MODULES_HEADER) + buf.write("\n\n") + write_frozen_modules_map(buf, modules) + buf.write("\n") + write_frozen_lookup(buf, modules) + buf.write("}\n") + generated = buf.getvalue() + + if content is not None and content == generated: + print(f"{file} not modified") + return + + # Content differs (or file is missing). Now try to update the real file. + # If the source filesystem is read-only, this will fail. os.makedirs(os.path.dirname(file), exist_ok=True) with open(file, "w", encoding="utf-8", newline=linesep) as out_file: - out_file.write(FROZEN_MODULES_HEADER) - out_file.write("\n\n") - write_frozen_modules_map(out_file, modules) - out_file.write("\n") - write_frozen_lookup(out_file, modules) - out_file.write("}\n") - with open(file, "r", encoding="utf-8", newline=linesep) as f: - new_content = f.read() - if new_content == content: - # set mtime to the old one, if we didn't change anything - print(f"{file} not modified") - os.utime(file, (atime, mtime)) - else: - print(f"{file} modified, rebuild needed!") - sys.exit(1) + out_file.write(generated) + + print(f"{file} modified, rebuild needed!") + sys.exit(1) def add_tabs(str, number): diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/CMakeLists.txt b/graalpython/com.oracle.graal.python.pegparser.generator/CMakeLists.txt index e142d96be6..d2e122430c 100644 --- a/graalpython/com.oracle.graal.python.pegparser.generator/CMakeLists.txt +++ b/graalpython/com.oracle.graal.python.pegparser.generator/CMakeLists.txt @@ -1,5 +1,5 @@ -cmake_minimum_required(VERSION 3.0) -project(pegparser) +cmake_minimum_required(VERSION 3.10) +project(pegparser LANGUAGES NONE) set(PEGPARSER_SRC_PATH "${CMAKE_CURRENT_LIST_DIR}/../com.oracle.graal.python.pegparser/src") set(GRAALPY_SRC_PATH "${CMAKE_CURRENT_LIST_DIR}/../com.oracle.graal.python/src") @@ -14,7 +14,6 @@ else() set(PYTHON_EXE "python3") endif() -set(PARSER_OUTPUT "Parser.java") set(PARSER_TARGET "${PARSER_PATH}/Parser.java") set(GRAMMAR "${INPUT_PATH}/python.gram") @@ -33,17 +32,17 @@ file(GLOB_RECURSE ASDL_FILES set(ASDL_STAMP "Python.asdl.stamp") -add_custom_target(grammar ALL - DEPENDS "${PARSER_OUTPUT}") add_custom_command( - OUTPUT "${PARSER_OUTPUT}" - COMMAND ${PYTHON_EXE} "${CMAKE_CURRENT_LIST_DIR}/main_parser_gen.py" "${GRAMMAR}" "${TOKENS}" "${PARSER_TARGET}" - DEPENDS "${CMAKE_CURRENT_LIST_DIR}/main_parser_gen.py" "${GRAMMAR}" "${TOKENS}" "${PARSER_TARGET}" ${PEGEN_FILES} ${PEGJAVA_FILES}) + OUTPUT "${PARSER_TARGET}" + COMMAND "${PYTHON_EXE}" "${CMAKE_CURRENT_LIST_DIR}/main_parser_gen.py" "${GRAMMAR}" "${TOKENS}" "${PARSER_TARGET}" + DEPENDS "${CMAKE_CURRENT_LIST_DIR}/main_parser_gen.py" "${GRAMMAR}" "${TOKENS}" ${PEGEN_FILES} ${PEGJAVA_FILES}) -add_custom_target(asdl ALL - DEPENDS "${ASDL_STAMP}") add_custom_command( OUTPUT "${ASDL_STAMP}" - COMMAND ${PYTHON_EXE} "${CMAKE_CURRENT_LIST_DIR}/main_asdl_gen.py" "${ASDL}" --sst-path "${PEGPARSER_SRC_PATH}" --ast-path "${GRAALPY_SRC_PATH}" - COMMAND ${CMAKE_COMMAND} -E touch "${ASDL_STAMP}" + COMMAND "${PYTHON_EXE}" "${CMAKE_CURRENT_LIST_DIR}/main_asdl_gen.py" "${ASDL}" --sst-path "${PEGPARSER_SRC_PATH}" --ast-path "${GRAALPY_SRC_PATH}" --stamp "${ASDL_STAMP}" DEPENDS "${CMAKE_CURRENT_LIST_DIR}/main_asdl_gen.py" "${ASDL}" ${ASDL_FILES}) + +add_custom_target( + Parser + ALL + DEPENDS "${PARSER_TARGET}" "${ASDL_STAMP}") diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/asdl/asdl_java.py b/graalpython/com.oracle.graal.python.pegparser.generator/asdl/asdl_java.py index 0952ce2a4c..631c3c4a53 100755 --- a/graalpython/com.oracle.graal.python.pegparser.generator/asdl/asdl_java.py +++ b/graalpython/com.oracle.graal.python.pegparser.generator/asdl/asdl_java.py @@ -225,7 +225,7 @@ def visit_enum(self, c: model.Enum, emitter: java_file.Emitter): emitter.println() emitter.println(f'// {c.name.java}.{m.java}') self.emit_make_type(emitter, m, c.name, (), (), m.python) - emitter.println(f'{m.singleton_field} = factory.createSingleton({m.cls_field});') + emitter.println(f'{m.singleton_field} = AstTypeFactory.createSingleton({m.cls_field});') @staticmethod def emit_make_type(emitter: java_file.Emitter, name: model.Name, base_class: Optional[model.Name], diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/asdl/java_file.py b/graalpython/com.oracle.graal.python.pegparser.generator/asdl/java_file.py index 0f7ef7b5b1..c9076d5cd3 100644 --- a/graalpython/com.oracle.graal.python.pegparser.generator/asdl/java_file.py +++ b/graalpython/com.oracle.graal.python.pegparser.generator/asdl/java_file.py @@ -1,4 +1,4 @@ -# Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -39,10 +39,11 @@ import os import textwrap from contextlib import contextmanager +from io import StringIO from typing import Optional HEADER = """/* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -136,9 +137,9 @@ def create(out_dir_base: str, java_package: str, java_class_name: str): # Determine which line separator to use if os.path.exists(filename): with open(filename, "r", encoding="utf-8", newline=os.linesep) as f: - content = f.read() + old_content = f.read() if os.linesep != "\n": - if content.replace(os.linesep, "\n") == content: + if old_content.replace(os.linesep, "\n") == old_content: # Windows file has Unix line endings linesep = "\n" else: @@ -146,10 +147,25 @@ def create(out_dir_base: str, java_package: str, java_class_name: str): else: linesep = "\n" else: + old_content = None linesep = os.linesep - with open(filename, 'w', encoding="utf-8", newline=linesep) as f: - emitter = Emitter(f) - f.write(HEADER) - f.write(f'package {java_package};\n') - yield emitter + # Generate content in memory so we can compare with existing content and avoid + # rewriting unchanged files (e.g. in case of a read-only source filesystem). + buf = StringIO(newline=linesep) + emitter = Emitter(buf) + buf.write(HEADER) + buf.write(f'package {java_package};\n') + + yield emitter + + generated = buf.getvalue() + + if old_content is not None and old_content == generated: + # Not modified. + return + + # Content differs (or file is missing). Now try to update the real file. + # If the source filesystem is read-only, this will fail. + with open(filename, "w", encoding="utf-8", newline=linesep) as f: + f.write(generated) diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/main_asdl_gen.py b/graalpython/com.oracle.graal.python.pegparser.generator/main_asdl_gen.py index e48d2b0fec..aafe188072 100644 --- a/graalpython/com.oracle.graal.python.pegparser.generator/main_asdl_gen.py +++ b/graalpython/com.oracle.graal.python.pegparser.generator/main_asdl_gen.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -# Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -43,14 +43,32 @@ from asdl.asdl_java import generate +def stamp(sst_path: pathlib.Path, ast_path: pathlib.Path): + if sst_path.is_dir() and ast_path.is_dir(): + return [ + p.read_bytes() for p in sorted(sst_path.rglob("*")) if p.is_file() + ] + [ + p.read_bytes() for p in sorted(ast_path.rglob("*")) if p.is_file() + ] + else: + return [] + + def main(): parser = argparse.ArgumentParser() parser.add_argument("input_file", type=pathlib.Path) parser.add_argument("-S", "--sst-path", type=pathlib.Path, required=True) parser.add_argument("-A", "--ast-path", type=pathlib.Path, required=True) + parser.add_argument("--stamp", type=pathlib.Path, required=True) args = parser.parse_args() + + old_contents = stamp(args.sst_path, args.ast_path) generate(args.input_file, args.sst_path, args.ast_path) + if old_contents != stamp(args.sst_path, args.ast_path) or not args.stamp.exists(): + args.stamp.touch() + else: + print(f"{args.sst_path} and {args.ast_path} not modified") if __name__ == '__main__': diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/main_parser_gen.py b/graalpython/com.oracle.graal.python.pegparser.generator/main_parser_gen.py index e4fc96faee..c4417f5c29 100644 --- a/graalpython/com.oracle.graal.python.pegparser.generator/main_parser_gen.py +++ b/graalpython/com.oracle.graal.python.pegparser.generator/main_parser_gen.py @@ -41,6 +41,7 @@ import os import sys import tokenize +import io from pegen.build import generate_token_definitions from pegen.grammar_parser import GeneratedParser as GrammarParser @@ -71,34 +72,29 @@ def main(): # Determine which line separator to use if os.path.exists(args.output_file): - stat_result = os.stat(args.output_file) - atime, mtime = stat_result.st_atime, stat_result.st_mtime - with open(args.output_file, "r", encoding="utf-8", newline=os.linesep) as f: - content = f.read() - if os.linesep != "\n": - unix_content = content.replace(os.linesep, "\n") - if unix_content == content: - # Windows file has Unix line endings - linesep = "\n" - content = unix_content + with open(args.output_file, "rb") as f: + raw_old_content = f.read() + if b'\r\n' in raw_old_content: + linesep = '\r\n' else: - linesep = os.linesep - else: - linesep = "\n" + linesep = '\n' + with open(args.output_file, "r", encoding="utf-8") as f: + old_content = f.read() else: - content = None + old_content = None linesep = os.linesep - with open(args.output_file, "w", encoding="utf-8", newline=linesep) as file: - gen = JavaParserGenerator(grammar, all_tokens, exact_tokens, non_exact_tokens, file, debug=args.debug) - gen.generate(os.path.basename(args.grammar_file)) + out = io.StringIO() + class_name = os.path.splitext(os.path.basename(args.output_file))[0] + gen = JavaParserGenerator(grammar, all_tokens, exact_tokens, non_exact_tokens, out, class_name, debug=args.debug) + gen.generate(os.path.basename(args.grammar_file)) - with open(args.output_file, "r", encoding="utf-8", newline=linesep) as file: - new_content = file.read() - - if content == new_content: + if out.getvalue() != old_content: + print(f"Writing new {args.output_file}") + with open(args.output_file, "w", encoding="utf-8", newline=linesep) as f: + f.write(out.getvalue()) + else: print(f"{args.output_file} not modified") - os.utime(args.output_file, (atime, mtime)) if __name__ == '__main__': diff --git a/graalpython/com.oracle.graal.python.pegparser.generator/pegjava/java_generator.py b/graalpython/com.oracle.graal.python.pegparser.generator/pegjava/java_generator.py index 45bf6fc4e0..f936050b3b 100644 --- a/graalpython/com.oracle.graal.python.pegparser.generator/pegjava/java_generator.py +++ b/graalpython/com.oracle.graal.python.pegparser.generator/pegjava/java_generator.py @@ -874,10 +874,12 @@ def __init__( exact_tokens: Dict[str, int], non_exact_tokens: Set[str], file: Optional[IO[Text]], + class_name: str, debug: bool = True, skip_actions: bool = False, ): super().__init__(grammar, set(tokens.values()), file) + self.class_name = class_name self.typingvisitor = TypingVisitor(self) # Java type hack self.callmakervisitor = JavaCallMakerVisitor(self, exact_tokens, non_exact_tokens, self.print) self.lookahead_functions: Dict[str, FunctionCall] = {} @@ -930,10 +932,9 @@ def generate(self, filename: str) -> None: self.print(f"// Generated from {filename} by pegen") self.print("package com.oracle.graal.python.pegparser;") self.print(IMPORTS) - className = os.path.splitext(os.path.basename(self.file.name))[0] self.print('@SuppressWarnings({"all", "cast"})') self.print('@SuppressFBWarnings') - self.print("public final class %s extends AbstractParser {" % className) + self.print("public final class %s extends AbstractParser {" % self.class_name) # Java needs a few fields declarations. Also, we're now in a class self.level += 1 self.print() @@ -945,12 +946,12 @@ def generate(self, filename: str) -> None: self.print(f"private static final int {rulename.upper()}_ID = {i};{comment}") self.print() # Java needs a constructor - self.print("public %s(String source, SourceRange sourceRange, ParserCallbacks parserCb, InputType startRule, EnumSet flags, int featureVersion) {" % className) + self.print("public %s(String source, SourceRange sourceRange, ParserCallbacks parserCb, InputType startRule, EnumSet flags, int featureVersion) {" % self.class_name) with self.indent(): self.print("super(source, sourceRange, parserCb, startRule, flags, featureVersion);") self.print("}") self.print() - self.print("public %s(String source, ParserCallbacks parserCb, InputType startRule, EnumSet flags, int featureVersion) {" % className) + self.print("public %s(String source, ParserCallbacks parserCb, InputType startRule, EnumSet flags, int featureVersion) {" % self.class_name) with self.indent(): self.print("super(source, null, parserCb, startRule, flags, featureVersion);") self.print("}") diff --git a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/customIter01.scope b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/customIter01.scope index 158c803ef3..56680c35a9 100644 --- a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/customIter01.scope +++ b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/customIter01.scope @@ -27,7 +27,7 @@ ScopeEnvironment StopIteration: [Use, GlobalImplicit] self: [DefParam, Local] Scope gen Function - Flags: [IsNested, HasFreeVars, IsGenerator] + Flags: [IsNested, HasFreeVars, IsGenerator, IsGeneratorWithYieldFrom] Symbols: MyIter: [Use, Free] - ret: [DefLocal, DefNonLocal, Free] \ No newline at end of file + ret: [DefLocal, DefNonLocal, Free] diff --git a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield12.scope b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield12.scope index ba68d74f71..2d0e71c0ff 100644 --- a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield12.scope +++ b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield12.scope @@ -3,4 +3,4 @@ ScopeEnvironment Symbols: f: [DefLocal, Local] Scope f Function - Flags: [IsGenerator] \ No newline at end of file + Flags: [IsGenerator, IsGeneratorWithYieldFrom] diff --git a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield13.scope b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield13.scope index 4b8b0cd348..f495687066 100644 --- a/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield13.scope +++ b/graalpython/com.oracle.graal.python.pegparser.test/testData/parser/goldenFiles/YieldStatementTests/yield13.scope @@ -3,6 +3,6 @@ ScopeEnvironment Symbols: f: [DefLocal, Local] Scope f Function - Flags: [IsGenerator] + Flags: [IsGenerator, IsGeneratorWithYieldFrom] Symbols: - f: [Use, GlobalImplicit] \ No newline at end of file + f: [Use, GlobalImplicit] diff --git a/graalpython/com.oracle.graal.python.pegparser/pom.xml b/graalpython/com.oracle.graal.python.pegparser/pom.xml new file mode 100644 index 0000000000..a6dbf87d88 --- /dev/null +++ b/graalpython/com.oracle.graal.python.pegparser/pom.xml @@ -0,0 +1,63 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.pegparser + jar + + + + org.graalvm.shadowed + icu4j + + + diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/Parser.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/Parser.java index 5c9183ac50..d7c0846fd0 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/Parser.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/Parser.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/Scope.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/Scope.java index 9deeb14704..e5baf83b72 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/Scope.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/Scope.java @@ -119,7 +119,8 @@ enum ScopeFlags { NeedsClassClosure, NeedsClassDict, IsVisitingIterTarget, - CanSeeClassScope + CanSeeClassScope, + IsGeneratorWithYieldFrom, } EnumSet flags = EnumSet.noneOf(ScopeFlags.class); @@ -243,6 +244,10 @@ public boolean isGenerator() { return flags.contains(ScopeFlags.IsGenerator); } + public boolean isGeneratorWithYieldFrom() { + return flags.contains(ScopeFlags.IsGeneratorWithYieldFrom); + } + public boolean isCoroutine() { return flags.contains(ScopeFlags.IsCoroutine); } diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/ScopeEnvironment.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/ScopeEnvironment.java index 3bb2bbe4bf..d64f82c530 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/ScopeEnvironment.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/scope/ScopeEnvironment.java @@ -920,6 +920,7 @@ public Void visit(ExprTy.YieldFrom node) { node.value.accept(this); } currentScope.flags.add(ScopeFlags.IsGenerator); + currentScope.flags.add(ScopeFlags.IsGeneratorWithYieldFrom); if (currentScope.flags.contains(ScopeFlags.IsComprehension)) { throw raiseIfComprehensionBlock(node); } diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/AliasTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/AliasTy.java index a492e85003..6d32f7c4ee 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/AliasTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/AliasTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgTy.java index 07c350cef1..cd8424278d 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgumentsTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgumentsTy.java index f73083ec50..a817b72195 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgumentsTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ArgumentsTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/BoolOpTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/BoolOpTy.java index e62e44bcb0..d69a8c2e19 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/BoolOpTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/BoolOpTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/CmpOpTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/CmpOpTy.java index 2f154eb844..83fc3aa81d 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/CmpOpTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/CmpOpTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ComprehensionTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ComprehensionTy.java index f42a5e1427..20dadbcb5a 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ComprehensionTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ComprehensionTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExceptHandlerTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExceptHandlerTy.java index 6c0aa13c2f..1b8f05a1cd 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExceptHandlerTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExceptHandlerTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprContextTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprContextTy.java index e6f4f850b1..c00e0008fc 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprContextTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprContextTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprTy.java index 1fb5d88c9d..ffce004cde 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ExprTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/KeywordTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/KeywordTy.java index 32aeca4faf..3e3fbc736c 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/KeywordTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/KeywordTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/MatchCaseTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/MatchCaseTy.java index f7f80b4fd7..ae95ba1287 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/MatchCaseTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/MatchCaseTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ModTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ModTy.java index 6ea70dcabe..732e480a2d 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ModTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/ModTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/OperatorTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/OperatorTy.java index 15222bba8b..b8f66b23ad 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/OperatorTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/OperatorTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/PatternTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/PatternTy.java index 4b6ff77335..ec48d65cda 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/PatternTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/PatternTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/SSTreeVisitor.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/SSTreeVisitor.java index fbc557ff1e..76017e195a 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/SSTreeVisitor.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/SSTreeVisitor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/StmtTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/StmtTy.java index 4a923ad404..dd6c1e1839 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/StmtTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/StmtTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeIgnoreTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeIgnoreTy.java index c5952df203..a07527e511 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeIgnoreTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeIgnoreTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeParamTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeParamTy.java index 0fe499b948..0eaaddd3e1 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeParamTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/TypeParamTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/UnaryOpTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/UnaryOpTy.java index 03b2e2d6a6..b3d36ea972 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/UnaryOpTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/UnaryOpTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/WithItemTy.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/WithItemTy.java index 7a102ea40f..75b4f19709 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/WithItemTy.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/sst/WithItemTy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/tokenizer/SourceRange.java b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/tokenizer/SourceRange.java index 63e788dfd7..14c494e99b 100644 --- a/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/tokenizer/SourceRange.java +++ b/graalpython/com.oracle.graal.python.pegparser/src/com/oracle/graal/python/pegparser/tokenizer/SourceRange.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2022, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -64,6 +64,14 @@ public SourceRange withEnd(int newEndLine, int newEndColumn) { return new SourceRange(startLine, startColumn, newEndLine, newEndColumn); } + public SourceRange startLineShiftColumn(int shift) { + assert shift >= 0; + if (shift == 0 || this == ARTIFICIAL_RANGE) { + return this; + } + return new SourceRange(startLine, startColumn, startLine, startColumn + shift); + } + public SourceRange shiftStartRight(int columns) { assert columns >= 0; if (columns == 0) { diff --git a/graalpython/com.oracle.graal.python.processor/pom.xml b/graalpython/com.oracle.graal.python.processor/pom.xml new file mode 100644 index 0000000000..061e5e11bd --- /dev/null +++ b/graalpython/com.oracle.graal.python.processor/pom.xml @@ -0,0 +1,63 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.processor + jar + + + + ${project.groupId} + com.oracle.graal.python.annotations + + + diff --git a/graalpython/com.oracle.graal.python.processor/src/META-INF/services/javax.annotation.processing.Processor b/graalpython/com.oracle.graal.python.processor/src/META-INF/services/javax.annotation.processing.Processor index 84137ac45b..c56a7e9bd4 100644 --- a/graalpython/com.oracle.graal.python.processor/src/META-INF/services/javax.annotation.processing.Processor +++ b/graalpython/com.oracle.graal.python.processor/src/META-INF/services/javax.annotation.processing.Processor @@ -1,4 +1,5 @@ com.oracle.graal.python.processor.ArgumentClinicProcessor com.oracle.graal.python.processor.GenerateEnumConstantsProcessor +com.oracle.graal.python.processor.GenerateNativeDowncallsProcessor com.oracle.graal.python.processor.CApiBuiltinsProcessor -com.oracle.graal.python.processor.SlotsProcessor \ No newline at end of file +com.oracle.graal.python.processor.SlotsProcessor diff --git a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/ArgumentClinicProcessor.java b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/ArgumentClinicProcessor.java index 2bc7b0bbe9..537fb5fd2f 100644 --- a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/ArgumentClinicProcessor.java +++ b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/ArgumentClinicProcessor.java @@ -82,9 +82,9 @@ public class ArgumentClinicProcessor extends AbstractProcessor { private static final boolean LOGGING = false; - private static final String BuiltinAnnotationClass = "com.oracle.graal.python.builtins.Builtin"; + private static final String BuiltinAnnotationClass = "com.oracle.graal.python.annotations.Builtin"; private static final String SlotSignatureAnnotationClass = "com.oracle.graal.python.annotations.Slot.SlotSignature"; - private static final String BuiltinsAnnotationClass = "com.oracle.graal.python.builtins.Builtins"; + private static final String BuiltinsAnnotationClass = "com.oracle.graal.python.annotations.Builtins"; private static final String BUILTINS_BASE_CLASSES_PACKAGE = "com.oracle.graal.python.nodes.function.builtins"; private Element[] clinicBuiltinBaseClasses; diff --git a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/CApiBuiltinsProcessor.java b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/CApiBuiltinsProcessor.java index 523dd21cdb..3176849381 100644 --- a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/CApiBuiltinsProcessor.java +++ b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/CApiBuiltinsProcessor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,19 +40,25 @@ */ package com.oracle.graal.python.processor; +import static com.oracle.graal.python.processor.NativeDowncallMethodHandleGenerator.argName; + import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.TreeSet; import java.util.stream.Collectors; +import java.util.stream.IntStream; import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.ProcessingEnvironment; @@ -64,22 +70,36 @@ import javax.lang.model.element.ElementKind; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.Modifier; +import javax.lang.model.element.Name; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeKind; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.AbstractAnnotationValueVisitor14; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; import javax.tools.Diagnostic.Kind; import javax.tools.StandardLocation; +import com.oracle.graal.python.annotations.CApiConstant; import com.oracle.graal.python.annotations.CApiConstants; +import com.oracle.graal.python.annotations.CApiExternalFunctionSignatures; import com.oracle.graal.python.annotations.CApiFields; import com.oracle.graal.python.annotations.CApiStructs; +import com.oracle.graal.python.annotations.CApiUpcallTarget; +import com.oracle.graal.python.annotations.NativeSimpleType; import com.sun.source.tree.VariableTree; import com.sun.source.util.TreePathScanner; import com.sun.source.util.Trees; public class CApiBuiltinsProcessor extends AbstractProcessor { + private static final String TRUFFLE_VIRTUAL_FRAME = "com.oracle.truffle.api.frame.VirtualFrame"; + private static final String TRUFFLE_NODE = "com.oracle.truffle.api.nodes.Node"; + private static final String NATIVE_FUNCTION_POINTER = "com.oracle.graal.python.runtime.nativeaccess.NativeFunctionPointer"; + private static final String PYTHON_CONTEXT = "com.oracle.graal.python.runtime.PythonContext"; + private static final String TARGET_PACKAGE = "com.oracle.graal.python.builtins.modules.cext"; + private static class ArgDescriptorsTreeScanner extends TreePathScanner { private Map initializerMap; @@ -95,6 +115,10 @@ public Object visitVariable(VariableTree variableTree, Trees trees) { private Map signatureToArgDescriptor = new HashMap<>(); private Map argDescriptorToInitializer = new HashMap<>(); + + private Map externalFunctionSignatureToInitializer = new HashMap<>(); + private Map nativeCAPISymbolToInitializer = new HashMap<>(); + private Trees trees; private String getFieldInitializer(VariableElement theField) { @@ -115,6 +139,34 @@ private String getFieldInitializer(VariableElement theField) { return argDescriptorToInitializer.get(name(theField)); } + private String getExternalFunctionSignatureInitializer(VariableElement theField) { + if (trees == null) { + return ""; + } + if (externalFunctionSignatureToInitializer.isEmpty()) { + // lazily initialize all external function signatures in a single scan + var codeScanner = new ArgDescriptorsTreeScanner(); + var tp = trees.getPath(theField.getEnclosingElement()); + codeScanner.initializerMap = externalFunctionSignatureToInitializer; + codeScanner.scan(tp, this.trees); + } + return externalFunctionSignatureToInitializer.get(name(theField)); + + } + + private String getNativeCAPISymbolInitializer(VariableElement theField) { + if (trees == null) { + return ""; + } + if (nativeCAPISymbolToInitializer.isEmpty()) { + var codeScanner = new ArgDescriptorsTreeScanner(); + var tp = trees.getPath(theField.getEnclosingElement()); + codeScanner.initializerMap = nativeCAPISymbolToInitializer; + codeScanner.scan(tp, this.trees); + } + return nativeCAPISymbolToInitializer.get(name(theField)); + } + @Override public synchronized void init(ProcessingEnvironment pe) { super.init(pe); @@ -141,6 +193,12 @@ private static String getCSignature(String initializer) { } } + private static String[] splitInitializerArgs(String initializer) { + int start = initializer.indexOf('('); + int end = initializer.lastIndexOf(')'); + return initializer.substring(start + 1, end).split(","); + } + private static boolean isVarArgs(VariableElement obj) { return name(obj).equals("VARARGS"); } @@ -155,12 +213,27 @@ private boolean isValidReturnType(VariableElement obj) { return !initializer.matches("ArgBehavior\\.PyObject[,)]") || initializer.contains("true"); } - private boolean isVoid(VariableElement obj) { - return getFieldInitializer(obj).contains("ArgBehavior.Void"); + private static String name(Element obj) { + return obj.getSimpleName().toString(); } - private static String name(VariableElement obj) { - return obj.getSimpleName().toString(); + private static String formatCConstantValue(VariableElement constant, Object value) { + TypeKind kind = constant.asType().getKind(); + return switch (kind) { + case BOOLEAN -> ((Boolean) value) ? "1" : "0"; + case BYTE, SHORT, INT -> value.toString(); + case LONG -> value + "LL"; + case CHAR -> Integer.toString((Character) value); + case FLOAT -> { + float f = (Float) value; + yield Float.isFinite(f) ? Float.toString(f) + "f" : null; + } + case DOUBLE -> { + double d = (Double) value; + yield Double.isFinite(d) ? Double.toString(d) : null; + } + default -> null; + }; } private static final class CApiBuiltinDesc { @@ -169,31 +242,88 @@ private static final class CApiBuiltinDesc { public final VariableElement[] arguments; public final VariableElement returnType; public final boolean acquireGil; + public final boolean canRaise; public final String call; public final String factory; public int id; - public CApiBuiltinDesc(Element origin, String name, VariableElement returnType, VariableElement[] arguments, boolean acquireGil, String call, String factory) { + public CApiBuiltinDesc(Element origin, String name, VariableElement returnType, VariableElement[] arguments, boolean acquireGil, boolean canRaise, String call, String factory) { this.origin = origin; this.name = name; this.returnType = returnType; this.arguments = arguments; this.acquireGil = acquireGil; + this.canRaise = canRaise; this.call = call; this.factory = factory; } } - private static String argName(int i) { - return "" + (char) ('a' + i); + private static final class CApiConstantDesc { + public final Element origin; + public final String name; + public final String value; + + public CApiConstantDesc(Element origin, String name, String value) { + this.origin = origin; + this.name = name; + this.value = value; + } + } + + private String capiTypeToLogicalType(VariableElement element) { + var init = getFieldInitializer(element); + if (init.contains("Void")) { + return "void"; + } else if (init.contains("Float64")) { + return "double"; + } else if (init.contains("Float32")) { + return "float"; + } else if (init.contains("Int32")) { + return "int"; + } else if (init.contains("Char16")) { + return "short"; + } else if (init.contains("Char8")) { + return "byte"; + } else if (init.contains("PyObject") || init.contains("Pointer")) { + return "pointer"; + } else { + return "long"; + } + } + + private boolean isVoid(VariableElement element) { + return capiTypeToLogicalType(element).equals("void"); + } + + private String capiTypeToErrorValue(VariableElement element) { + if (capiTypeToLogicalType(element).equals("pointer")) { + return "0"; + } else { + return "-1"; + } + } + + private String capiTypeToJavaPrimitiveType(VariableElement element) { + var type = capiTypeToLogicalType(element); + return type.equals("pointer") ? "long" : type; + } + + private String capiTypeToForeignPrimitiveType(VariableElement element) { + String type = capiTypeToJavaPrimitiveType(element); + return type.equals("void") ? "void" : ("j" + type); } private static final String CAPI_BUILTIN = "com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltin"; private static final String CAPI_BUILTINS = "com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltins"; + private static final String CAPI_WRAPPER_DESCRIPTOR = "com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.CApiWrapperDescriptor"; + private static final String INVOKE_EXTERNAL_FUNCTION = "com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.InvokeExternalFunction"; @Override public Set getSupportedAnnotationTypes() { - return Set.of(CAPI_BUILTIN, CAPI_BUILTINS, CApiFields.class.getName(), CApiConstants.class.getName(), CApiStructs.class.getName()); + return Set.of(CAPI_BUILTIN, CAPI_BUILTINS, CApiFields.class.getName(), + CApiConstant.class.getName(), CApiConstants.class.getName(), CApiStructs.class.getName(), + CApiExternalFunctionSignatures.class.getName()); } @Override @@ -359,11 +489,16 @@ private void addCApiBuiltins(RoundEnvironment re, List javaBuil } var ret = findValue(builtin, "ret", VariableElement.class); boolean acquireGil = findValue(builtin, "acquireGil", Boolean.class); + boolean canRaise = findValue(builtin, "canRaise", Boolean.class); + if (acquireGil && !canRaise) { + processingEnv.getMessager().printError(String.format("Invalid @CApiBuiltin %s: if acquireGil is true, canRaise must be true as well (a safepoint action may run)", name, ret)); + continue; + } String call = name(findValue(builtin, "call", VariableElement.class)); // boolean inlined = findValue(builtin, "inlined", Boolean.class); VariableElement[] args = findValues(builtin, "args", VariableElement.class).toArray(new VariableElement[0]); - if (((TypeElement) element).getQualifiedName().toString().equals("com.oracle.graal.python.builtins.objects.cext.capi.CApiFunction.Dummy")) { - additionalBuiltins.add(new CApiBuiltinDesc(element, builtinName, ret, args, acquireGil, call, null)); + if (element instanceof TypeElement te && te.getQualifiedName().toString().equals("com.oracle.graal.python.builtins.objects.cext.capi.CApiFunction.Dummy")) { + additionalBuiltins.add(new CApiBuiltinDesc(element, builtinName, ret, args, acquireGil, canRaise, call, null)); } else { if (!isValidReturnType(ret)) { processingEnv.getMessager().printError( @@ -389,8 +524,12 @@ private void addCApiBuiltins(RoundEnvironment re, List javaBuil } else { genName += "NodeGen"; } - verifyNodeClass(((TypeElement) element), builtin); - javaBuiltins.add(new CApiBuiltinDesc(element, name, ret, args, acquireGil, call, genName)); + if (element instanceof TypeElement te) { + verifyNodeClass(te, builtin); + } else { + verifyStaticMethod((ExecutableElement) element, builtin); + } + javaBuiltins.add(new CApiBuiltinDesc(element, name, ret, args, acquireGil, canRaise, call, genName)); } } } @@ -401,6 +540,14 @@ private void addCApiBuiltins(RoundEnvironment re, List javaBuil } } + private void verifyStaticMethod(ExecutableElement e, AnnotationMirror annotation) { + if (!e.getModifiers().contains(Modifier.STATIC)) { + processingEnv.getMessager().printError("CApiBuiltins must be nodes or static methods", e); + } else if (e.getParameters().size() != findValues(annotation, "args", VariableElement.class).size()) { + processingEnv.getMessager().printError("Arity mismatch between declared arguments and static method", e); + } + } + private void verifyNodeClass(TypeElement te, AnnotationMirror annotation) { var tm = te.asType(); while (tm instanceof DeclaredType dt) { @@ -474,14 +621,19 @@ private String getArgSignatureWithName(VariableElement arg, int i) { * * @throws IOException */ - private void generateCApiSource(List javaBuiltins, List constants, List fields, List structs) throws IOException { + private void generateCApiSource(List javaBuiltins, List constants, List fields, List structs, List capiSymbols) throws IOException { ArrayList lines = new ArrayList<>(); for (var entry : javaBuiltins) { String name = entry.name; CApiBuiltinDesc value = entry; if (value.call.equals("Direct") || value.call.equals("NotImplemented")) { lines.add("#undef " + name); - String line = "PyAPI_FUNC(" + getCSignature(value.returnType) + ") " + name + "("; + String line; + if (name.startsWith("GraalPyPrivate_")) { + line = "GraalPy_CAPI_HELPER_SYMBOL " + getCSignature(value.returnType) + " " + name + "("; + } else { + line = "PyAPI_FUNC(" + getCSignature(value.returnType) + ") " + name + "("; + } for (int i = 0; i < value.arguments.length; i++) { line += (i == 0 ? "" : ", ") + getArgSignatureWithName(value.arguments[i], i); } @@ -502,17 +654,11 @@ private void generateCApiSource(List javaBuiltins, List } } - lines.add("PyAPI_FUNC(int64_t*) GraalPyPrivate_Constants() {"); - lines.add(" static int64_t constants[] = {"); + lines.add("Py_EXPORTED_SYMBOL int64_t GraalPy_CAPI_METADATA[] = {"); for (var constant : constants) { lines.add(" (int64_t) " + constant + ","); } - lines.add(" 0xdead1111 // marker value"); - lines.add(" };"); - lines.add(" return constants;"); - lines.add("}"); - lines.add("PyAPI_FUNC(Py_ssize_t*) GraalPyPrivate_StructOffsets() {"); - lines.add(" static Py_ssize_t offsets[] = {"); + lines.add(" 0xdead1111, // constants marker value"); for (var field : fields) { int delim = field.indexOf("__"); assert delim != -1; @@ -521,34 +667,40 @@ private void generateCApiSource(List javaBuiltins, List name = name.replace("__", "."); // to allow inlined structs lines.add(" offsetof(" + struct + ", " + name + "),"); } - lines.add(" 0xdead2222 // marker value"); - lines.add(" };"); - lines.add(" return offsets;"); - lines.add("}"); - lines.add("PyAPI_FUNC(Py_ssize_t*) GraalPyPrivate_StructSizes() {"); - lines.add(" static Py_ssize_t sizes[] = {"); + lines.add(" 0xdead2222, // struct offsets marker value"); for (var struct : structs) { lines.add(" sizeof(" + struct.replace("__", " ") + "),"); } - lines.add(" 0xdead3333 // marker value"); + lines.add(" 0xdead3333 // struct sizes marker value"); lines.add(" };"); - lines.add(" return sizes;"); - lines.add("}"); + lines.add(""); + lines.add("Py_EXPORTED_SYMBOL void *GraalPy_CAPI_HELPERS[] = {"); + for (var helper : capiSymbols) { + lines.add(" (void *)" + helper.cName + ","); + } + lines.add("};"); updateResource("capi.gen.c.h", javaBuiltins, lines); } - private void updateResource(String name, List javaBuiltins, List lines) throws IOException { - var origins = javaBuiltins.stream().map((jb) -> jb.origin).toArray(Element[]::new); + private void updateResource(String name, List javaBuiltins, List additionalOrigins, + List lines, StandardLocation loc) + throws IOException { + var originsList = new ArrayList(); + for (var javaBuiltin : javaBuiltins) { + originsList.add(javaBuiltin.origin); + } + originsList.addAll(additionalOrigins); + var origins = originsList.toArray(Element[]::new); String oldContents = ""; String newContents = String.join(System.lineSeparator(), lines); try { - oldContents = processingEnv.getFiler().getResource(StandardLocation.NATIVE_HEADER_OUTPUT, "", name).getCharContent(true).toString(); + oldContents = processingEnv.getFiler().getResource(loc, "", name).getCharContent(true).toString(); } catch (IOException e) { // pass to regenerate } if (!oldContents.equals(newContents)) { - var file = processingEnv.getFiler().createResource(StandardLocation.NATIVE_HEADER_OUTPUT, "", name, origins); + var file = processingEnv.getFiler().createResource(loc, "", name, origins); try (var w = file.openWriter()) { w.append(newContents); } @@ -557,13 +709,132 @@ private void updateResource(String name, List javaBuiltins, Lis } } + private void updateResource(String name, List javaBuiltins, List lines, + StandardLocation loc) throws IOException { + updateResource(name, javaBuiltins, List.of(), lines, loc); + } + + private void updateResource(String name, List javaBuiltins, List lines) throws IOException { + updateResource(name, javaBuiltins, lines, StandardLocation.NATIVE_HEADER_OUTPUT); + } + + private Map getArgDescriptorsByName() { + TypeElement argDescriptorType = processingEnv.getElementUtils().getTypeElement("com.oracle.graal.python.builtins.objects.cext.capi.transitions.ArgDescriptor"); + if (argDescriptorType == null) { + processingEnv.getMessager().printError("Could not resolve ArgDescriptor while generating C API helper declarations."); + return Map.of(); + } + Map result = new HashMap<>(); + for (var element : argDescriptorType.getEnclosedElements()) { + if (element.getKind() == ElementKind.ENUM_CONSTANT) { + result.put(name(element), (VariableElement) element); + } + } + return result; + } + + private static final class CApiSymbolDesc { + final String cName; + final CApiExternalFunctionSignatureDesc signature; + + CApiSymbolDesc(String cName, CApiExternalFunctionSignatureDesc signature) { + this.cName = cName; + this.signature = signature; + } + } + + private List collectNativeCAPISymbols(Map externalFunctionSignatures) { + TypeElement nativeCAPISymbolType = processingEnv.getElementUtils().getTypeElement("com.oracle.graal.python.builtins.objects.cext.capi.NativeCAPISymbol"); + if (nativeCAPISymbolType == null) { + processingEnv.getMessager().printError("Could not resolve NativeCAPISymbol while generating C API helper declarations."); + return List.of(); + } + List helpers = new ArrayList<>(); + for (var element : nativeCAPISymbolType.getEnclosedElements()) { + if (element.getKind() != ElementKind.ENUM_CONSTANT) { + continue; + } + String initializer = getNativeCAPISymbolInitializer((VariableElement) element); + String[] args = splitInitializerArgs(initializer); + if (args.length < 2) { + processingEnv.getMessager().printError("Invalid NativeCAPISymbol initializer for " + name(element), element); + continue; + } + String cName = args[0].strip().replace("\"", ""); + String signatureName = args[1].strip(); + int lastDot = signatureName.lastIndexOf('.'); + if (lastDot >= 0) { + signatureName = signatureName.substring(lastDot + 1); + } + CApiExternalFunctionSignatureDesc signature = externalFunctionSignatures.get(signatureName); + if (signature == null) { + processingEnv.getMessager().printError("Could not resolve C API helper signature " + signatureName + " for " + name(element), element); + continue; + } + helpers.add(new CApiSymbolDesc(cName, signature)); + } + return helpers; + } + + private void addCApiSymbolDeclarations(List lines, List capiSymbols) { + List declarations = new ArrayList<>(); + Map argDescriptors = getArgDescriptorsByName(); + for (var helper : capiSymbols) { + if (!helper.cName.startsWith("GraalPyPrivate_")) { + continue; + } + String externalFunctionSignatureInitializer = getExternalFunctionSignatureInitializer(helper.signature.origin); + String[] signatureArgs = splitInitializerArgs(externalFunctionSignatureInitializer); + if (signatureArgs.length < 2) { + processingEnv.getMessager().printError("Invalid C API helper signature initializer for " + helper.signature.name, helper.signature.origin); + continue; + } + VariableElement returnType = argDescriptors.get(signatureArgs[1].strip()); + if (returnType == null) { + processingEnv.getMessager().printError("Could not resolve return type " + signatureArgs[1].strip() + " for C API helper " + helper.cName, helper.signature.origin); + continue; + } + String line = "GraalPy_CAPI_HELPER_SYMBOL " + getCSignature(returnType) + " " + helper.cName + "("; + if (signatureArgs.length == 2) { + line += "void"; + } else { + boolean valid = true; + for (int i = 2; i < signatureArgs.length; i++) { + String argType = signatureArgs[i].strip(); + VariableElement arg = argDescriptors.get(argType); + if (arg == null) { + processingEnv.getMessager().printError("Could not resolve argument type " + argType + " for C API helper " + helper.cName, helper.signature.origin); + valid = false; + break; + } + line += (i == 2 ? "" : ", ") + getArgSignatureWithName(arg, i - 2); + } + if (!valid) { + continue; + } + } + line += ");"; + declarations.add(line); + } + lines.add("PyAPI_DATA(void *) GraalPy_CAPI_HELPERS[];"); + lines.add("PyAPI_DATA(int64_t) GraalPy_CAPI_METADATA[];"); + lines.add(""); + lines.addAll(declarations); + } + /** * Generates the builtin specification in capi.h, which includes only the builtins implemented * in Java code. Additionally, it generates helpers for all "GraalPyPrivate_Get_" and * "GraalPyPrivate_Set_" builtins. */ - private void generateCApiHeader(List javaBuiltins) throws IOException { + private void generateCApiHeader(List javaBuiltins, List javaConstants, List capiSymbols) throws IOException { List lines = new ArrayList<>(); + for (var javaConstant : javaConstants) { + lines.add("#define " + javaConstant.name + " " + javaConstant.value); + } + if (!javaConstants.isEmpty()) { + lines.add(""); + } lines.add("#define CAPI_BUILTINS \\"); int id = 0; for (var entry : javaBuiltins) { @@ -578,6 +849,9 @@ private void generateCApiHeader(List javaBuiltins) throws IOExc } lines.add(""); + addCApiSymbolDeclarations(lines, capiSymbols); + lines.add(""); + for (var entry : javaBuiltins) { String name = entry.name; if (entry.origin.getEnclosingElement().getSimpleName().toString().equals("PythonCextSlotBuiltins")) { @@ -607,7 +881,109 @@ private void generateCApiHeader(List javaBuiltins) throws IOExc } } - updateResource("capi.gen.h", javaBuiltins, lines); + updateResource("capi.gen.h", javaBuiltins, javaConstants.stream().map((c) -> c.origin).toList(), lines, + StandardLocation.NATIVE_HEADER_OUTPUT); + } + + /** + * Generates the native image config for the direct upcalls to the builtins. + */ + private void generateUpcallConfig(List javaBuiltins, List explicitUpcallTargets) throws IOException { + ArrayList lines = new ArrayList<>(); + lines.add("{"); + lines.add(" \"foreign\": {"); + lines.add(" \"directUpcalls\": ["); + + for (int i = 0; i < javaBuiltins.size(); i++) { + var builtin = javaBuiltins.get(i); + String argString = Arrays.stream(builtin.arguments).map(b -> '"' + capiTypeToForeignPrimitiveType(b) + '"').collect(Collectors.joining(", ")); + String classString = getUpcallTargetClass(builtin); + String methodString = getUpcallTargetMethod(builtin); + lines.add(" {"); + emitDirectUpcall(lines, classString, methodString, capiTypeToForeignPrimitiveType(builtin.returnType), argString); + if (i < javaBuiltins.size() - 1 || !explicitUpcallTargets.isEmpty()) { + lines.add(" },"); + } else { + lines.add(" }"); + } + } + for (int i = 0; i < explicitUpcallTargets.size(); i++) { + ExecutableElement explicitUpcallTarget = explicitUpcallTargets.get(i); + + if (!verifySignatureOfExplicitUpcallTarget(explicitUpcallTarget)) { + continue; + } + + Element enclosingElement = explicitUpcallTarget.getEnclosingElement(); + if (enclosingElement.getKind() != ElementKind.CLASS) { + processingEnv.getMessager().printError("Method is expected to be enclosed by a class", explicitUpcallTarget); + continue; + } + String classString = processingEnv.getElementUtils().getBinaryName((TypeElement) enclosingElement).toString(); + String methodString = explicitUpcallTarget.getSimpleName().toString(); + String argString = explicitUpcallTarget.getParameters().stream().map(VariableElement::asType).map(t -> '"' + toJNIName(t) + '"').collect(Collectors.joining(", ")); + lines.add(" {"); + emitDirectUpcall(lines, classString, methodString, explicitUpcallTarget.getReturnType().toString(), argString); + if (i < explicitUpcallTargets.size() - 1) { + lines.add(" },"); + } else { + lines.add(" }"); + } + } + lines.add(" ]"); + lines.add(" }"); + lines.add("}"); + + updateResource("META-INF/native-image/com.oracle.graal.python.capi/reachability-metadata.json", javaBuiltins, lines, StandardLocation.CLASS_OUTPUT); + } + + private static boolean usesUpcallWrapper(CApiBuiltinDesc builtin) { + return builtin.origin instanceof TypeElement || builtin.canRaise; + } + + private static String getUpcallTargetClass(CApiBuiltinDesc builtin) { + if (usesUpcallWrapper(builtin)) { + return "com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltinRegistry"; + } + return ((TypeElement) builtin.origin.getEnclosingElement()).getQualifiedName().toString(); + } + + private static String getUpcallTargetMethod(CApiBuiltinDesc builtin) { + if (usesUpcallWrapper(builtin)) { + return "upcall_" + builtin.name; + } + return builtin.origin.getSimpleName().toString(); + } + + private static void emitDirectUpcall(ArrayList lines, String classString, String methodString, String returnType, String argString) { + lines.add(" \"class\": \"" + classString + "\","); + lines.add(" \"method\": \"" + methodString + "\","); + lines.add(" \"returnType\": \"" + returnType + "\","); + lines.add(" \"parameterTypes\": [" + argString + "]"); + } + + private static String toJNIName(TypeMirror typeMirror) { + assert typeMirror.getKind().isPrimitive(); + if (typeMirror.getKind() == TypeKind.VOID) { + return "void"; + } + return "j" + typeMirror; + } + + private boolean verifySignatureOfExplicitUpcallTarget(ExecutableElement explicitUpcallTarget) { + if (!explicitUpcallTarget.getReturnType().getKind().isPrimitive()) { + processingEnv.getMessager().printError("Return type must be primitive but was " + explicitUpcallTarget.getReturnType(), explicitUpcallTarget); + return false; + } + + for (int i = 0; i < explicitUpcallTarget.getParameters().size(); i++) { + VariableElement variableElement = explicitUpcallTarget.getParameters().get(i); + if (!variableElement.asType().getKind().isPrimitive()) { + processingEnv.getMessager().printError("Parameter type must be primitive but was " + variableElement.asType(), variableElement); + return false; + } + } + return true; } /** @@ -616,26 +992,37 @@ private void generateCApiHeader(List javaBuiltins) throws IOExc */ private void generateBuiltinRegistry(List javaBuiltins) throws IOException { ArrayList lines = new ArrayList<>(); - - lines.add("// @formatter:off"); - lines.add("// Checkstyle: stop"); - lines.add("// Generated by annotation processor: " + getClass().getName()); - lines.add("package %s".formatted("com.oracle.graal.python.builtins.modules.cext;")); - lines.add(""); - lines.add("import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltinExecutable;"); - lines.add("import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltinNode;"); - lines.add("import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiCallPath;"); - lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.transitions.ArgDescriptor;"); - lines.add(""); - lines.add("public abstract class PythonCextBuiltinRegistry {"); - lines.add(""); - lines.add(" private PythonCextBuiltinRegistry() {"); - lines.add(" // no instances"); - lines.add(" }"); + // language=java + lines.add(""" + // @formatter:off + // Checkstyle: stop + // Generated by annotation processor: CApiBuiltinsProcessor + package %s; + + import java.lang.invoke.MethodHandle; + import java.lang.invoke.MethodHandles; + import java.lang.invoke.MethodType; + + import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins; + import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltinExecutable; + import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiBuiltinNode; + import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins.CApiCallPath; + import com.oracle.graal.python.builtins.objects.cext.capi.transitions.ArgDescriptor; + import com.oracle.graal.python.builtins.modules.cext.PythonCextBuiltins; + import com.oracle.graal.python.builtins.objects.cext.common.CExtCommonNodes.TransformPExceptionToNativeNode; + import com.oracle.graal.python.runtime.GilNode; + import com.oracle.graal.python.runtime.exception.PException; + + public final class PythonCextBuiltinRegistry { + + private PythonCextBuiltinRegistry() { + // no instances + } + """.formatted(TARGET_PACKAGE)); for (var builtin : javaBuiltins) { String argString = Arrays.stream(builtin.arguments).map(b -> "ArgDescriptor." + b).collect(Collectors.joining(", ")); - lines.add(" public static final CApiBuiltinExecutable " + builtin.name + " = new CApiBuiltinExecutable(\"" + builtin.name + "\", CApiCallPath." + builtin.call + ", ArgDescriptor." + + lines.add(" public static final CApiBuiltinExecutable " + builtin.name + " = new CApiBuiltinExecutable(\"" + builtin.name + "\", ArgDescriptor." + builtin.returnType + ", new ArgDescriptor[]{" + argString + "}, " + builtin.acquireGil + ", " + builtin.id + ");"); } lines.add(""); @@ -651,12 +1038,88 @@ private void generateBuiltinRegistry(List javaBuiltins) throws for (var builtin : javaBuiltins) { lines.add(" case " + builtin.id + ":"); - lines.add(" return " + builtin.factory + ".create();"); + if (builtin.origin instanceof ExecutableElement) { + lines.add(" throw new RuntimeException(\"Static builtins should never need a node, they are just a static method.\");"); + } else { + lines.add(" return " + builtin.factory + ".create();"); + } + } + + lines.add(" }"); + lines.add(" return null;"); + lines.add(" }"); + + lines.add(""); + for (var builtin : javaBuiltins) { + lines.add(" private static final MethodHandle HANDLE_" + builtin.name + ";"); + } + lines.add(" static {"); + lines.add(" try {"); + for (var builtin : javaBuiltins) { + String argString = Arrays.stream(builtin.arguments).map(b -> capiTypeToJavaPrimitiveType(b) + ".class").collect(Collectors.joining(", ")); + String classString = usesUpcallWrapper(builtin) ? "PythonCextBuiltinRegistry" : getUpcallTargetClass(builtin); + String methodString = '"' + getUpcallTargetMethod(builtin) + '"'; + lines.add(" HANDLE_" + builtin.name + " = MethodHandles.lookup().findStatic(" + classString + ".class, " + methodString + ", MethodType.methodType(" + + capiTypeToJavaPrimitiveType(builtin.returnType) + ".class" + (builtin.arguments.length > 0 ? ", " : "") + argString + "));"); } + lines.add(" } catch (NoSuchMethodException | IllegalAccessException e) {"); + lines.add(" throw new RuntimeException(e);"); + lines.add(" }"); + lines.add(" }"); + lines.add(""); + lines.add(" static MethodHandle getMethodHandle(int id) {"); + lines.add(" switch (id) {"); + for (var builtin : javaBuiltins) { + lines.add(" case " + builtin.id + ":"); + lines.add(" return HANDLE_" + builtin.name + ";"); + } lines.add(" }"); lines.add(" return null;"); lines.add(" }"); + + for (var builtin : javaBuiltins) { + if (builtin.origin instanceof ExecutableElement && !builtin.canRaise) { + // will be called directly + continue; + } + lines.add(""); + String argString = IntStream.range(0, builtin.arguments.length).mapToObj(i -> capiTypeToJavaPrimitiveType(builtin.arguments[i]) + " " + argName(i)).collect(Collectors.joining(", ")); + if (!(builtin.origin instanceof TypeElement) && builtin.acquireGil) { + lines.add(" @SuppressWarnings(\"try\")"); + } + lines.add(" public static " + capiTypeToJavaPrimitiveType(builtin.returnType) + " upcall_" + builtin.name + "(" + argString + ") {"); + String paramString = IntStream.range(0, builtin.arguments.length).mapToObj(i -> argName(i)).collect(Collectors.joining(", ")); + String retString = capiTypeToJavaPrimitiveType(builtin.returnType); + if (retString.equals("void")) { + retString = ""; + } else { + retString = "return (" + retString + ")"; + } + if (builtin.origin instanceof TypeElement) { + lines.add(" " + retString + builtin.name + ".getCallTarget().call(" + paramString + ");"); + } else { + if (!retString.isEmpty()) { + retString = "return "; + } + assert builtin.canRaise; + lines.add(" try {"); + lines.add(" try " + (builtin.acquireGil ? "(GilNode.UncachedAcquire gil = GilNode.uncachedAcquire()) " : "") + "{"); + lines.add(" " + retString + ((TypeElement) builtin.origin.getEnclosingElement()).getQualifiedName().toString() + "." + builtin.origin.getSimpleName().toString() + "(" + + paramString + ");"); + lines.add(" } catch (Throwable t) {"); + lines.add(" throw PythonCextBuiltins.checkThrowableBeforeNative(t, \"CApiBuiltin\", \"" + builtin.name + "\");"); + lines.add(" }"); + lines.add(" } catch (PException pe) {"); + lines.add(" TransformPExceptionToNativeNode.executeUncached(pe);"); + if (!retString.isEmpty()) { + lines.add(" return " + capiTypeToErrorValue(builtin.returnType) + ";"); + } + lines.add(" }"); + } + lines.add(" }"); + } + lines.add("}"); var origins = javaBuiltins.stream().map((jb) -> jb.origin).toArray(Element[]::new); @@ -671,7 +1134,7 @@ private void generateCApiAsserts(List allBuiltins) throws IOExc lines.add(""); for (var builtin : allBuiltins) { lines.add(" hasMember = reallyHasMember(capiLibrary, \"" + builtin.name + "\");"); - if (builtin.call.equals("CImpl") || builtin.call.equals("Direct") || builtin.call.equals("NotImplemented")) { + if (builtin.call.equals("CImpl") || builtin.call.equals("NotImplemented") || (builtin.call.equals("Direct") && !builtin.name.startsWith("GraalPyPrivate_"))) { lines.add(" if (!hasMember) messages.add(\"missing implementation: " + builtin.name + "\");"); } } @@ -680,38 +1143,29 @@ private void generateCApiAsserts(List allBuiltins) throws IOExc var origins = allBuiltins.stream().map((jb) -> jb.origin).toArray(Element[]::new); var file = processingEnv.getFiler().createSourceFile("com.oracle.graal.python.builtins.modules.cext.PythonCApiAssertions", origins); try (var w = file.openWriter()) { + // language=java w.append(""" // @formatter:off // Checkstyle: stop package %s; import java.util.TreeSet; - import com.oracle.truffle.api.CompilerDirectives; - import com.oracle.truffle.api.interop.InteropLibrary; - import com.oracle.truffle.api.interop.UnknownIdentifierException; - import com.oracle.truffle.api.interop.UnsupportedMessageException; + import com.oracle.graal.python.runtime.nativeaccess.NativeLibrary; - public abstract class PythonCApiAssertions { + public final class PythonCApiAssertions { private PythonCApiAssertions() { // no instances } - public static boolean reallyHasMember(Object capiLibrary, String name) { - try { - InteropLibrary.getUncached().readMember(capiLibrary, name); - } catch (UnsupportedMessageException e) { - throw CompilerDirectives.shouldNotReachHere(e); - } catch (UnknownIdentifierException e) { - return false; - } - return true; + private static boolean reallyHasMember(NativeLibrary capiLibrary, String name) { + return capiLibrary.lookupOptionalSymbol(name) != 0L; } /** * Checks whether the expected builtins exist in the library. */ - public static boolean assertBuiltins(Object capiLibrary) { + public static boolean assertBuiltins(NativeLibrary capiLibrary) { boolean hasMember = false; TreeSet messages = new TreeSet<>(); %s @@ -719,7 +1173,7 @@ public static boolean assertBuiltins(Object capiLibrary) { return messages.isEmpty(); } } - """.formatted("com.oracle.graal.python.builtins.modules.cext", String.join(System.lineSeparator(), lines))); + """.formatted(TARGET_PACKAGE, String.join(System.lineSeparator(), lines))); } } @@ -835,6 +1289,881 @@ private void checkImports(List builtins) throws IOException { } } + private static final class CApiExternalFunctionSignatureDesc { + public final VariableElement origin; + public final String name; + + String returnType; + String[] argumentTypes; + public boolean cannotRaise; + + public CApiExternalFunctionSignatureDesc(VariableElement origin, String name) { + this.origin = origin; + this.name = name; + } + } + + private record InvokeExternalFunctionDesc(ExecutableElement origin, VariableElement signature, TypeMirror returnType, List argumentTypes) { + } + + private static final String NATIVE_ACCESS_PACKAGE = "com.oracle.graal.python.runtime.nativeaccess"; + private static final String NATIVE_ACCESS_SUPPORT_CLASS_NAME = "NativeAccessSupport"; + private static final String NATIVE_ACCESS_SUPPORT_IMPL_CLASS_NAME = "NativeAccessSupportJdk22Gen"; + private static final String EXFUNC_INVOKER_PACKAGE = "com.oracle.graal.python.builtins.objects.cext.capi"; + private static final String EXFUNC_INVOKER_CLASS_NAME = "ExternalFunctionInvoker"; + + /** + * Find classes annotated with {@link #CAPI_WRAPPER_DESCRIPTOR} and methods annotated with + * {@link #INVOKE_EXTERNAL_FUNCTION} and store the extraced information in + * {@link CApiExternalFunctionWrapperDesc} and {@link InvokeExternalFunctionDesc}, respectively. + */ + private List collectExternalFunctionAndWrapperDescs(RoundEnvironment re, List wrappers) { + List wrapperDescs = new ArrayList<>(); + + // TODO: remove this as soon as the annotation 'INVOKE_EXTERNAL_FUNCTION' is accessible by + // this processor + for (var rootElement : re.getRootElements()) { + collectExternalFunctionAndWrapperDescs(rootElement, wrapperDescs, wrappers); + } + return wrapperDescs; + } + + private void collectExternalFunctionAndWrapperDescs(Element element, List wrapperDescs, List wrappers) { + AnnotationMirror invokeAnnot = findAnnotationMirror(element, INVOKE_EXTERNAL_FUNCTION); + if (invokeAnnot != null) { + assert element.getKind() == ElementKind.METHOD; + VariableElement signatureElement = findValue(invokeAnnot, "value", VariableElement.class); + TypeMirror retConversion = findValue(invokeAnnot, "retConversion", TypeMirror.class); + List argConversion = findValues(invokeAnnot, "argConversions", TypeMirror.class); + wrapperDescs.add(new InvokeExternalFunctionDesc((ExecutableElement) element, signatureElement, retConversion, argConversion)); + } + + AnnotationMirror wrapperAnnot = findAnnotationMirror(element, CAPI_WRAPPER_DESCRIPTOR); + if (wrapperAnnot != null) { + List wrapperNames = findValues(wrapperAnnot, "value", VariableElement.class); + wrappers.add(new CApiExternalFunctionWrapperDesc(element, wrapperNames)); + } + + for (Element enclosedElement : element.getEnclosedElements()) { + collectExternalFunctionAndWrapperDescs(enclosedElement, wrapperDescs, wrappers); + } + } + + /** + * Maps an {@code com.oracle.graal.python.builtins.objects.cext.capi.transitions.ArgBehavior} to + * the native Java carrier type. + */ + private String toJavaNfiType(String argDescriptor) { + // TODO: types should be inferred with: 'ArgDescriptor.behavior.nativeSimpleType' + return switch (argDescriptor) { + case "Void" -> "void"; + case "Int", "InquiryResult", "InitResult", "PrimitiveResult32" -> "int"; + case "Double" -> "double"; + case "Float" -> "float"; + case "Py_hash_t", "Py_ssize_t", "PrimitiveResult64", "INT64_T", "INT64_T_PTR", "INTPTR_T_PTR", "SIZE_T", "UINTPTR_T", "Long", "UNSIGNED_LONG", "UINT64_T", + "PyObjectReturn", "PyObject", "PyObjectTransfer", "PyObjectConstArray", "PyObjectPtr", "PyTypeObject", "ConstPyLongObject", "PyThreadState", "PyThreadStatePtr", + "CharPtrAsTruffleString", "IterResult", "Pointer", "CHAR_PTR", "ConstCharPtr", "INT8_T_PTR", "PY_BUFFER_PTR", "PY_CAPSULE_DESTRUCTOR", "PY_SSIZE_T_PTR", "VA_LIST", + "visitproc" -> + "long"; + default -> { + processingEnv.getMessager().printError(String.format("Unexpected ArgDescriptor: '%s'", argDescriptor)); + yield null; + } + }; + } + + private static String getSimpleName(TypeMirror typeMirror) { + if (typeMirror.getKind() == TypeKind.DECLARED) { + return ((DeclaredType) typeMirror).asElement().getSimpleName().toString(); + } + return typeMirror.toString(); + } + + private TypeMirror toJavaNfiType(TypeMirror typeMirror) { + if (typeMirror.getKind() == TypeKind.VOID && typeMirror.getKind().isPrimitive()) { + return typeMirror; + } + return processingEnv.getTypeUtils().getPrimitiveType(TypeKind.LONG); + } + + private boolean isCannotRaise(VariableElement signature) { + String externalFunctionSignatureInitializer = getExternalFunctionSignatureInitializer(signature); + String[] initArgs = splitInitializerArgs(externalFunctionSignatureInitializer); + return Boolean.parseBoolean(initArgs[0].strip()); + } + + private boolean isWrapperRootInvoke(InvokeExternalFunctionDesc wrapper) { + TypeMirror wrapperBaseRoot = processingEnv.getElementUtils().getTypeElement(EXFUNC_INVOKER_PACKAGE + ".ExternalFunctionNodes.WrapperBaseRoot").asType(); + return processingEnv.getTypeUtils().isSubtype(wrapper.origin.getEnclosingElement().asType(), wrapperBaseRoot); + } + + private static String getGeneratedExternalInvokeHelperClassName(Element clazz) { + return clazz.getSimpleName() + "Gen"; + } + + private void generateExternalFunctionInvoker(List signatures) throws IOException { + ArrayList lines = new ArrayList<>(); + + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + EXFUNC_INVOKER_PACKAGE + ";"); + lines.add(""); + lines.add("import java.lang.invoke.MethodHandle;"); + lines.add("import java.lang.invoke.MethodType;"); + lines.add(""); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.EnsurePythonObjectNode;"); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTiming;"); + lines.add("import com.oracle.graal.python.builtins.objects.function.PArguments;"); + lines.add("import " + NATIVE_ACCESS_PACKAGE + ".NativeFunctionPointer;"); + lines.add("import " + NATIVE_ACCESS_PACKAGE + ".NativeContext;"); + lines.add("import " + NATIVE_ACCESS_PACKAGE + "." + NATIVE_ACCESS_SUPPORT_CLASS_NAME + ";"); + lines.add("import com.oracle.graal.python.runtime.ExecutionContext.BoundaryCallContext;"); + lines.add("import com.oracle.graal.python.runtime.GilNode;"); + lines.add("import com.oracle.graal.python.runtime.IndirectCallData.BoundaryCallData;"); + lines.add("import com.oracle.graal.python.runtime.PythonContext;"); + lines.add("import com.oracle.graal.python.runtime.PythonContext.PythonThreadState;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;"); + lines.add("import " + TRUFFLE_VIRTUAL_FRAME + ";"); + lines.add(""); + lines.add("public final class " + EXFUNC_INVOKER_CLASS_NAME + " {"); + lines.add(""); + lines.add(" private " + EXFUNC_INVOKER_CLASS_NAME + "() {"); + lines.add(" // no instances"); + lines.add(" }"); + lines.add(""); + + // resolve return and argument types and declare downcall method handles + for (CApiExternalFunctionSignatureDesc sig : signatures) { + // determine arg types and return type for signature; initializer syntax: + // 'ExternalFunctionSignature(ArgDescriptor returnValue, ArgDescriptor... arguments)' + String externalFunctionSignatureInitializer = getExternalFunctionSignatureInitializer(sig.origin); + + String[] initArgs = splitInitializerArgs(externalFunctionSignatureInitializer); + + assert !sig.cannotRaise; + sig.cannotRaise = Boolean.valueOf(initArgs[0].strip()); + assert sig.returnType == null; + sig.returnType = initArgs[1].strip(); + assert sig.argumentTypes == null; + sig.argumentTypes = Arrays.stream(initArgs).skip(2).map(String::strip).toArray(String[]::new); + } + + for (CApiExternalFunctionSignatureDesc sig : signatures) { + assert sig.returnType != null; + assert sig.argumentTypes != null; + String returnType = toJavaNfiType(sig.returnType); + List argTypes = Arrays.stream(sig.argumentTypes).map(this::toJavaNfiType).toList(); + + boolean isVoidReturn = "void".equals(returnType); + + List invokeArgs = new LinkedList<>(); + if (sig.cannotRaise) { + invokeArgs.add("CApiTiming timing"); + invokeArgs.add("NativeFunctionPointer nativeFunction"); + } else { + invokeArgs.add("VirtualFrame frame"); + invokeArgs.add("CApiTiming timing"); + invokeArgs.add("NativeContext nativeContext"); + invokeArgs.add("BoundaryCallData boundaryCallData"); + invokeArgs.add("PythonThreadState threadState"); + invokeArgs.add("NativeFunctionPointer nativeFunction"); + } + int i = 0; + for (String argType : argTypes) { + invokeArgs.add(argType + " " + argName(i++)); + } + + List cArgs = new LinkedList<>(); + i = 0; + for (int unused = 0; unused < argTypes.size(); unused++) { + cArgs.add(argName(i++)); + } + + List typedArgs = new LinkedList<>(); + i = 0; + for (String argType : argTypes) { + typedArgs.add(argType + " " + argName(i++)); + } + NativeDowncallMethodHandleGenerator.emitMethodHandleField(lines, NativeDowncallMethodHandleGenerator.methodHandleVarName(sig.name), returnType, argTypes); + + lines.add(""); + if (sig.cannotRaise) { + lines.add(" public static " + returnType + " invoke" + sig.name + "(" + String.join(", ", invokeArgs) + ") {"); + String returnStmt = isVoidReturn ? "" : "return "; + lines.add(" CApiTiming.enter();"); + lines.add(" try {"); + lines.add(" " + returnStmt + "invoke" + sig.name + "(" + + "nativeFunction.getAddress()" + + (cArgs.isEmpty() ? "" : ", " + String.join(", ", cArgs)) + ");"); + lines.add(" } catch (Throwable exception) {"); + lines.add(" throw CompilerDirectives.shouldNotReachHere(exception);"); + lines.add(" } finally {"); + lines.add(" CApiTiming.exit(timing);"); + lines.add(" }"); + lines.add(" }"); + lines.add(""); + } else { + List contextInvokeArgs = new LinkedList<>(); + contextInvokeArgs.add("VirtualFrame frame"); + contextInvokeArgs.add("CApiTiming timing"); + contextInvokeArgs.add("PythonContext context"); + contextInvokeArgs.add("NativeFunctionPointer nativeFunction"); + contextInvokeArgs.addAll(typedArgs); + + String returnStmt = isVoidReturn ? "" : "return "; + + List nullFrameInvokeArgs = new LinkedList<>(); + nullFrameInvokeArgs.add("CApiTiming timing"); + nullFrameInvokeArgs.add("PythonContext context"); + nullFrameInvokeArgs.add("NativeFunctionPointer nativeFunction"); + nullFrameInvokeArgs.addAll(typedArgs); + lines.add(""); + + lines.add(" public static " + returnType + " invoke" + sig.name + "(" + String.join(", ", invokeArgs) + ") {"); + for (int j = 0; j < argTypes.size(); j++) { + if (argTypes.get(j).contains("PyObject")) { + lines.add(" assert EnsurePythonObjectNode.doesNotNeedPromotion(" + argName(j) + ");"); + } + } + lines.add(" // If any code requested the caught exception (i.e. used 'sys.exc_info()'), we store;"); + lines.add(" // it to the context since we cannot propagate it through the native frames."); + lines.add(""); + lines.add(" Object state = BoundaryCallContext.enter(frame, threadState, boundaryCallData);"); + lines.add(" CApiTiming.enter();"); + lines.add(" try {"); + lines.add(" " + returnStmt + "invoke" + sig.name + "(" + + "nativeFunction.getAddress()" + + (cArgs.isEmpty() ? "" : ", " + String.join(", ", cArgs)) + ");"); + lines.add(" } catch (Throwable exception) {"); + lines.add(" CompilerDirectives.transferToInterpreterAndInvalidate();"); + lines.add(" GilNode.uncachedAcquire();"); + lines.add(" throw CompilerDirectives.shouldNotReachHere(exception);"); + lines.add(" } finally {"); + lines.add(" CApiTiming.exit(timing);"); + lines.add(" if (frame != null && threadState.getCaughtException() != null) {"); + lines.add(" PArguments.setException(frame, threadState.getCaughtException());"); + lines.add(" }"); + lines.add(" BoundaryCallContext.exit(frame, threadState, state);"); + lines.add(" }"); + lines.add(" }"); + lines.add(""); + } + + List rawInvokeArgs = new LinkedList<>(); + rawInvokeArgs.add("long function"); + i = 0; + for (String argType : argTypes) { + rawInvokeArgs.add(argType + " " + argName(i++)); + } + + lines.add(" @TruffleBoundary(allowInlining = true, transferToInterpreterOnException = false)"); + lines.add(" public static " + returnType + " invoke" + sig.name + "(" + String.join(", ", rawInvokeArgs) + ") throws Throwable {"); + String directArgExpr = cArgs.isEmpty() ? "function" : "function, " + String.join(", ", cArgs); + if (isVoidReturn) { + lines.add(" " + NativeDowncallMethodHandleGenerator.methodHandleVarName(sig.name) + ".invokeExact(" + directArgExpr + ");"); + } else { + lines.add(" return (" + returnType + ") " + NativeDowncallMethodHandleGenerator.methodHandleVarName(sig.name) + ".invokeExact(" + directArgExpr + ");"); + } + lines.add(" }"); + } + lines.add("}"); + + var origins = signatures.stream().map((sig) -> sig.origin).toArray(Element[]::new); + var file = processingEnv.getFiler().createSourceFile(EXFUNC_INVOKER_PACKAGE + "." + EXFUNC_INVOKER_CLASS_NAME, origins); + try (var w = file.openWriter()) { + w.append(String.join(System.lineSeparator(), lines)); + } + } + + private void generateNativeAccessSupport(Element[] origins) throws IOException { + if (Runtime.version().feature() < 22) { + generateDummyNativeAccessSupport(origins); + return; + } + ArrayList lines = new ArrayList<>(); + + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + NATIVE_ACCESS_PACKAGE + ";"); + lines.add(""); + lines.add("import java.lang.foreign.Arena;"); + lines.add("import java.lang.foreign.FunctionDescriptor;"); + lines.add("import java.lang.foreign.Linker;"); + lines.add("import java.lang.foreign.MemoryLayout;"); + lines.add("import java.lang.foreign.MemorySegment;"); + lines.add("import java.lang.foreign.SymbolLookup;"); + lines.add("import java.lang.foreign.ValueLayout;"); + lines.add("import java.lang.invoke.MethodHandle;"); + lines.add("import java.lang.invoke.MethodHandles;"); + lines.add("import java.lang.invoke.MethodType;"); + lines.add("import java.util.OptionalLong;"); + lines.add(""); + lines.add("import static com.oracle.truffle.api.CompilerDirectives.shouldNotReachHere;"); + lines.add("import " + NativeSimpleType.class.getCanonicalName() + ";"); + lines.add(""); + lines.add("public final class " + NATIVE_ACCESS_SUPPORT_IMPL_CLASS_NAME + " extends " + NATIVE_ACCESS_SUPPORT_CLASS_NAME + " {"); + lines.add(" private static final MethodHandle OF_ADDRESS;"); + lines.add(""); + lines.add(" static {"); + lines.add(" try {"); + lines.add(" OF_ADDRESS = MethodHandles.lookup().findStatic(MemorySegment.class, \"ofAddress\", MethodType.methodType(MemorySegment.class, long.class));"); + lines.add(" } catch (NoSuchMethodException | IllegalAccessException e) {"); + lines.add(" throw new RuntimeException(e);"); + lines.add(" }"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected Object createArenaImpl() {"); + lines.add(" return Arena.ofShared();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected void closeArenaImpl(Object arena) {"); + lines.add(" ((Arena) arena).close();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" @SuppressWarnings(\"restricted\")"); + lines.add(" protected NativeLibraryLookup libraryLookupImpl(String name, Object arena) {"); + lines.add(" SymbolLookup lookup = SymbolLookup.libraryLookup(name, (Arena) arena);"); + lines.add(" return symbolName -> lookup.find(symbolName).map(segment -> OptionalLong.of(segment.address())).orElseGet(OptionalLong::empty);"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected long lookupDefaultImpl(String name) {"); + lines.add(" return Linker.nativeLinker().defaultLookup().find(name).orElseThrow().address();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" @SuppressWarnings(\"restricted\")"); + lines.add(" protected MethodHandle createDowncallHandleImpl(MethodType methodType, boolean critical) {"); + lines.add(" FunctionDescriptor functionDescriptor = createFunctionDescriptor(methodType);"); + lines.add(" Linker.Option[] options = critical ? new Linker.Option[] { Linker.Option.critical(false) } : new Linker.Option[0];"); + lines.add(" MethodHandle methodHandle = Linker.nativeLinker().downcallHandle(functionDescriptor, options);"); + lines.add(" methodHandle = MethodHandles.filterArguments(methodHandle, 0, OF_ADDRESS);"); + lines.add(" return methodHandle.asType(methodType);"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" @SuppressWarnings(\"restricted\")"); + lines.add(" protected long createClosureImpl(MethodHandle staticMethodHandle, NativeSimpleType resType, NativeSimpleType[] argTypes, Object arena) {"); + lines.add(" FunctionDescriptor functionDescriptor = createFunctionDescriptor(resType, argTypes);"); + lines.add(" return Linker.nativeLinker().upcallStub(staticMethodHandle, functionDescriptor, (Arena) arena).address();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected boolean isCurrentThreadVirtualImpl() {"); + lines.add(" return Thread.currentThread().isVirtual();"); + lines.add(" }"); + lines.add(""); + lines.add(" private static FunctionDescriptor createFunctionDescriptor(NativeSimpleType resType, NativeSimpleType[] argTypes) {"); + lines.add(" MemoryLayout[] argLayouts = new MemoryLayout[argTypes.length];"); + lines.add(" for (int i = 0; i < argTypes.length; i++) {"); + lines.add(" argLayouts[i] = asLayout(argTypes[i]);"); + lines.add(" }"); + lines.add(" return resType == NativeSimpleType.VOID ? FunctionDescriptor.ofVoid(argLayouts) : FunctionDescriptor.of(asLayout(resType), argLayouts);"); + lines.add(" }"); + lines.add(""); + lines.add(" private static FunctionDescriptor createFunctionDescriptor(MethodType methodType) {"); + lines.add(" Class[] parameterTypes = methodType.parameterArray();"); + lines.add(" MemoryLayout[] argLayouts = new MemoryLayout[parameterTypes.length - 1];"); + lines.add(" for (int i = 1; i < parameterTypes.length; i++) {"); + lines.add(" argLayouts[i - 1] = asLayout(parameterTypes[i]);"); + lines.add(" }"); + lines.add(" Class returnType = methodType.returnType();"); + lines.add(" return returnType == void.class ? FunctionDescriptor.ofVoid(argLayouts) : FunctionDescriptor.of(asLayout(returnType), argLayouts);"); + lines.add(" }"); + lines.add(""); + lines.add(" private static MemoryLayout asLayout(Class type) {"); + lines.add(" if (type == byte.class) {"); + lines.add(" return ValueLayout.JAVA_BYTE;"); + lines.add(" } else if (type == short.class) {"); + lines.add(" return ValueLayout.JAVA_SHORT;"); + lines.add(" } else if (type == int.class) {"); + lines.add(" return ValueLayout.JAVA_INT;"); + lines.add(" } else if (type == long.class) {"); + lines.add(" return ValueLayout.JAVA_LONG;"); + lines.add(" } else if (type == float.class) {"); + lines.add(" return ValueLayout.JAVA_FLOAT;"); + lines.add(" } else if (type == double.class) {"); + lines.add(" return ValueLayout.JAVA_DOUBLE;"); + lines.add(" }"); + lines.add(" throw shouldNotReachHere(\"Unsupported layout carrier: \" + type);"); + lines.add(" }"); + lines.add(""); + lines.add(" private static MemoryLayout asLayout(NativeSimpleType type) {"); + lines.add(" return switch (type) {"); + lines.add(" case VOID -> throw shouldNotReachHere(\"VOID has no layout\");"); + lines.add(" case SINT8 -> ValueLayout.JAVA_BYTE;"); + lines.add(" case SINT16 -> ValueLayout.JAVA_SHORT;"); + lines.add(" case SINT32 -> ValueLayout.JAVA_INT;"); + lines.add(" case SINT64 -> ValueLayout.JAVA_LONG;"); + lines.add(" case FLOAT -> ValueLayout.JAVA_FLOAT;"); + lines.add(" case DOUBLE -> ValueLayout.JAVA_DOUBLE;"); + lines.add(" case POINTER -> ValueLayout.JAVA_LONG;"); + lines.add(" };"); + lines.add(" }"); + lines.add("}"); + + var file = processingEnv.getFiler().createSourceFile(NATIVE_ACCESS_PACKAGE + "." + NATIVE_ACCESS_SUPPORT_IMPL_CLASS_NAME, origins); + try (var w = file.openWriter()) { + w.append(String.join(System.lineSeparator(), lines)); + } + } + + private void generateDummyNativeAccessSupport(Element[] origins) throws IOException { + ArrayList lines = new ArrayList<>(); + + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + NATIVE_ACCESS_PACKAGE + ";"); + lines.add(""); + lines.add("import java.lang.invoke.MethodHandle;"); + lines.add("import java.lang.invoke.MethodType;"); + lines.add(""); + lines.add("import " + NativeSimpleType.class.getCanonicalName() + ";"); + lines.add(""); + lines.add("public final class " + NATIVE_ACCESS_SUPPORT_IMPL_CLASS_NAME + " extends " + NATIVE_ACCESS_SUPPORT_CLASS_NAME + " {"); + lines.add(" @Override"); + lines.add(" protected Object createArenaImpl() {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected void closeArenaImpl(Object arena) {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected NativeLibraryLookup libraryLookupImpl(String name, Object arena) {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected long lookupDefaultImpl(String name) {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected MethodHandle createDowncallHandleImpl(MethodType methodType, boolean critical) {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected long createClosureImpl(MethodHandle staticMethodHandle, NativeSimpleType resType, NativeSimpleType[] argTypes, Object arena) {"); + lines.add(" throw unsupported();"); + lines.add(" }"); + lines.add(""); + lines.add(" @Override"); + lines.add(" protected boolean isCurrentThreadVirtualImpl() {"); + lines.add(" return false;"); + lines.add(" }"); + lines.add("}"); + + var file = processingEnv.getFiler().createSourceFile(NATIVE_ACCESS_PACKAGE + "." + NATIVE_ACCESS_SUPPORT_IMPL_CLASS_NAME, origins); + try (var w = file.openWriter()) { + w.append(String.join(System.lineSeparator(), lines)); + } + } + + /** + * @param wrapperNames enum constant names denoting wrapper descriptors + */ + private record CApiExternalFunctionWrapperDesc(Element origin, List wrapperNames) { + } + + private boolean verifyArguments(ExecutableElement origin, String... expectedPrefixArgs) { + if (origin.getParameters().size() < expectedPrefixArgs.length) { + processingEnv.getMessager().printError(String.format("Method \"%s\" must at least have parameters %s.", origin, Arrays.toString(expectedPrefixArgs)), origin); + return false; + } + assert origin.getParameters().size() >= expectedPrefixArgs.length; + Iterator iterator = origin.getParameters().iterator(); + for (int i = 0; i < expectedPrefixArgs.length; i++) { + VariableElement formalParameter = iterator.next(); + TypeElement te = (TypeElement) processingEnv.getTypeUtils().asElement(formalParameter.asType()); + + if (!expectedPrefixArgs[i].equals(te.getQualifiedName().toString())) { + processingEnv.getMessager().printError(String.format("Argument %d of method \"%s\" must be of type \"%s\" but was \"%s\"", i, origin, expectedPrefixArgs[i], formalParameter), origin); + return false; + } + } + return true; + } + + private static boolean needsConversion(TypeMirror type) { + return !type.getKind().isPrimitive() && type.getKind() != TypeKind.VOID; + } + + private static boolean needsReachabilityFence(TypeMirror type) { + return !type.getKind().isPrimitive() && type.getKind() != TypeKind.NULL; + } + + /** + * Lookup a method in {@code enclosingType} that exactly satisfies the specified signature and + * has the given name prefix. + */ + private ExecutableElement findMethod(Element location, TypeMirror enclosingType, String prefix, TypeMirror retType, TypeMirror... argTypes) { + Types typeUtils = processingEnv.getTypeUtils(); + Elements elementUtils = processingEnv.getElementUtils(); + + Element el = typeUtils.asElement(enclosingType); + if (!(el instanceof TypeElement typeElement)) { + processingEnv.getMessager().printError("Type %s does not have any executable methods.", location); + // Not a declared type (could be primitive, array, type variable, etc.) + return null; + } + + for (Element e : elementUtils.getAllMembers(typeElement)) { + if (e.getKind() == ElementKind.METHOD && e.getSimpleName().toString().startsWith(prefix)) { + ExecutableElement method = (ExecutableElement) e; + // if (retType.equals(method.getReturnType()) && + // argType.equals(method.getParameters().get(0).asType()) ) { + TypeMirror[] parameters = method.getParameters().stream().map(VariableElement::asType).toArray(TypeMirror[]::new); + if (retType.equals(method.getReturnType()) && Arrays.equals(parameters, argTypes)) { + return method; + } + } + } + processingEnv.getMessager().printError(String.format("Type %s does not have any \"%s %s*(%s)\" method.", + enclosingType, retType, prefix, Arrays.stream(argTypes).map(Object::toString).collect(Collectors.joining(", "))), location); + return null; + } + + private static final String WRAPPER_DESCRIPTOR_GEN_CLASS_NAME = "WrapperDescriptorRootNodesGen"; + + private void generateExternalFunctionHelperNodes(List externalFunctionDescs) throws IOException { + final Types typeUtils = processingEnv.getTypeUtils(); + final Elements elementUtils = processingEnv.getElementUtils(); + TypeMirror nodeType = elementUtils.getTypeElement(TRUFFLE_NODE).asType(); + Map> helperInvokeDescsByClass = new LinkedHashMap<>(); + + for (InvokeExternalFunctionDesc desc : externalFunctionDescs) { + if (!isWrapperRootInvoke(desc)) { + TypeElement clazz = (TypeElement) desc.origin.getEnclosingElement(); + helperInvokeDescsByClass.computeIfAbsent(clazz, k -> new ArrayList<>()).add(desc); + } + } + + for (Map.Entry> entry : helperInvokeDescsByClass.entrySet()) { + TypeElement clazz = entry.getKey(); + if (!typeUtils.isSubtype(clazz.asType(), nodeType)) { + processingEnv.getMessager().printError(String.format("Type %s must extend %s.", clazz, TRUFFLE_NODE), clazz); + return; + } + + String packageName = elementUtils.getPackageOf(clazz).getQualifiedName().toString(); + String genClassName = getGeneratedExternalInvokeHelperClassName(clazz); + ArrayList lines = new ArrayList<>(); + + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + packageName + ";"); + lines.add(""); + lines.add("import " + clazz.getQualifiedName() + ";"); + lines.add("import " + EXFUNC_INVOKER_PACKAGE + "." + EXFUNC_INVOKER_CLASS_NAME + ";"); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTiming;"); + lines.add("import " + NATIVE_FUNCTION_POINTER + ";"); + lines.add("import " + PYTHON_CONTEXT + ";"); + lines.add("import com.oracle.graal.python.runtime.IndirectCallData.BoundaryCallData;"); + lines.add("import " + TRUFFLE_VIRTUAL_FRAME + ";"); + lines.add(""); + lines.add("public final class " + genClassName + " extends " + clazz.getSimpleName() + " {"); + lines.add(""); + lines.add(" private static final " + genClassName + " UNCACHED = new " + genClassName + "();"); + lines.add(""); + for (InvokeExternalFunctionDesc helper : entry.getValue()) { + lines.add(" private static final CApiTiming TIMING_" + helper.origin.getSimpleName() + " = CApiTiming.create(true, \"" + helper.origin.getSimpleName() + "\");"); + } + lines.add(""); + lines.add(" private " + genClassName + "() {"); + lines.add(" }"); + lines.add(""); + lines.add(" public static " + clazz.getSimpleName() + " create() {"); + lines.add(" return new " + genClassName + "();"); + lines.add(" }"); + lines.add(""); + lines.add(" public static " + clazz.getSimpleName() + " getUncached() {"); + lines.add(" return UNCACHED;"); + lines.add(" }"); + + for (InvokeExternalFunctionDesc helper : entry.getValue()) { + List formalParameters = helper.origin.getParameters(); + boolean isVoidReturn = helper.origin.getReturnType().getKind() == TypeKind.VOID; + boolean cannotRaise = isCannotRaise(helper.signature); + + if (!verifyArguments(helper.origin, TRUFFLE_VIRTUAL_FRAME, PYTHON_CONTEXT, NATIVE_FUNCTION_POINTER)) { + return; + } + + int actualArgConversionClasses = helper.argumentTypes.size(); + int expectedArgConversionClasses = formalParameters.size() - 3; + if (actualArgConversionClasses != expectedArgConversionClasses) { + processingEnv.getMessager().printError(String.format("You need to specify exactly %d argument conversion classes but there were %d.", + expectedArgConversionClasses, actualArgConversionClasses), helper.origin); + return; + } + + List methodInvokeFormalArgs = new ArrayList<>(formalParameters.size()); + List cArgs = new ArrayList<>(); + if (cannotRaise) { + cArgs.add("TIMING_" + helper.origin.getSimpleName()); + cArgs.add(formalParameters.get(2).getSimpleName().toString()); // nativeFunction + } else { + cArgs.add(formalParameters.get(0).getSimpleName().toString()); // frame + cArgs.add("TIMING_" + helper.origin.getSimpleName()); + cArgs.add(formalParameters.get(1).getSimpleName().toString()); // context + cArgs.add(formalParameters.get(2).getSimpleName().toString()); // nativeFunction + } + + for (VariableElement formalParameter : formalParameters) { + TypeMirror type = formalParameter.asType(); + Element element = typeUtils.asElement(type); + String typeString = element != null ? element.getSimpleName().toString() : type.toString(); + methodInvokeFormalArgs.add(typeString + " " + formalParameter.getSimpleName()); + } + for (int i = 3; i < formalParameters.size(); i++) { + cArgs.add(formalParameters.get(i).getSimpleName().toString()); + } + + lines.add(""); + lines.add(" @Override"); + lines.add(" protected " + getSimpleName(helper.origin.getReturnType()) + " " + helper.origin.getSimpleName() + "(" + String.join(", ", methodInvokeFormalArgs) + ") {"); + if (isVoidReturn) { + lines.add(" " + EXFUNC_INVOKER_CLASS_NAME + ".invoke" + helper.signature + "(" + String.join(", ", cArgs) + ");"); + } else { + lines.add(" return " + EXFUNC_INVOKER_CLASS_NAME + ".invoke" + helper.signature + "(" + String.join(", ", cArgs) + ");"); + } + lines.add(" }"); + } + + lines.add("}"); + + var origins = entry.getValue().stream().map((desc) -> desc.origin).toArray(Element[]::new); + var file = processingEnv.getFiler().createSourceFile(packageName + "." + genClassName, origins); + try (var w = file.openWriter()) { + w.append(String.join(System.lineSeparator(), lines)); + } + } + } + + private void generateExternalFunctionRootNodes(List externalFunctionDescs, List wrappers, + @SuppressWarnings("unused") Map externalFunctionSignatures) throws IOException { + final Types typeUtils = processingEnv.getTypeUtils(); + List wrapperInvokeDescs = externalFunctionDescs.stream().filter(this::isWrapperRootInvoke).toList(); + ArrayList lines = new ArrayList<>(); + + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + EXFUNC_INVOKER_PACKAGE + ";"); + lines.add(""); + + lines.add("import com.oracle.graal.python.PythonLanguage;"); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.CExtNodes.EnsurePythonObjectNode;"); + for (InvokeExternalFunctionDesc wrapper : wrapperInvokeDescs) { + Element clazz = wrapper.origin.getEnclosingElement(); + lines.add("import " + EXFUNC_INVOKER_PACKAGE + "." + clazz.getEnclosingElement().getSimpleName() + "." + clazz.getSimpleName() + ";"); + } + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.PExternalFunctionWrapper;"); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.WrapperDescriptorRoot;"); + lines.add("import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTiming;"); + lines.add("import " + NATIVE_FUNCTION_POINTER + ";"); + lines.add("import com.oracle.graal.python.runtime.ExecutionContext.CalleeContext;"); + lines.add("import com.oracle.graal.python.runtime.IndirectCallData.BoundaryCallData;"); + lines.add("import com.oracle.graal.python.runtime.PythonContext;"); + lines.add("import com.oracle.graal.python.runtime.PythonContext.GetThreadStateNode;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;"); + lines.add("import " + TRUFFLE_VIRTUAL_FRAME + ";"); + lines.add("import com.oracle.truffle.api.nodes.Node.Child;"); + lines.add("import com.oracle.truffle.api.strings.TruffleString;"); + lines.add(""); + int importMarker = lines.size(); + lines.add(""); + lines.add("import java.lang.ref.Reference;"); + lines.add(""); + lines.add("public final class " + WRAPPER_DESCRIPTOR_GEN_CLASS_NAME + " {"); + lines.add(""); + lines.add(" private " + WRAPPER_DESCRIPTOR_GEN_CLASS_NAME + "() {"); + lines.add(" // no instances"); + lines.add(" }"); + lines.add(""); + + Set classesToImport = new HashSet<>(); + + // declare downcall signature variables and resolve return and argument types + for (InvokeExternalFunctionDesc wrapper : wrapperInvokeDescs) { + boolean errorOccurred = false; + boolean cannotRaise = isCannotRaise(wrapper.signature); + + assert wrapper.returnType != null; + assert wrapper.argumentTypes != null; + List formalParameters = wrapper.origin.getParameters(); + + boolean isVoidReturn = wrapper.origin.getReturnType().getKind() == TypeKind.VOID; + + // verify arguments of annotated method + if (!verifyArguments(wrapper.origin, TRUFFLE_VIRTUAL_FRAME, NATIVE_FUNCTION_POINTER)) { + return; + } + + // check if the right count of argument conversion classes was specified + int actualArgConversionClasses = wrapper.argumentTypes.size(); + int expectedArgConversionClasses = formalParameters.size() - 2; + if (actualArgConversionClasses != expectedArgConversionClasses) { + processingEnv.getMessager().printError(String.format("You need to specify exactly %d argument conversion classes but there were %d.", + expectedArgConversionClasses, actualArgConversionClasses), wrapper.origin); + return; + } + + // formal arguments of method 'invokeExternalFunction' + List methodInvokeFormalArgs = new ArrayList<>(formalParameters.size()); + List needReachabilityFence = new LinkedList<>(); + for (VariableElement formalParameter : formalParameters) { + TypeMirror type = formalParameter.asType(); + Element element = typeUtils.asElement(type); + String typeString; + if (element != null) { + typeString = element.getSimpleName().toString(); + } else { + typeString = type.toString(); + } + methodInvokeFormalArgs.add(typeString + " " + formalParameter.getSimpleName()); + } + + // list of arguments passed to 'ExternalFunctionInvoker.invoke*' method + List cArgs = new LinkedList<>(); + if (cannotRaise) { + cArgs.add("timing"); + cArgs.add(formalParameters.get(1).getSimpleName().toString()); // nativeFunction + } else { + cArgs.add(formalParameters.getFirst().getSimpleName().toString()); // frame + cArgs.add("timing"); + cArgs.add("context.ensureNativeContext()"); + cArgs.add("boundaryCallData"); // boundaryCallData + cArgs.add("getThreadStateNode.executeCached(context)"); // threadState + cArgs.add(formalParameters.get(1).getSimpleName().toString()); // nativeFunction + } + + Element clazz = wrapper.origin.getEnclosingElement(); + String genClassName = clazz.getSimpleName() + "Gen"; + + lines.add(""); + lines.add(" public static final class " + genClassName + " extends " + clazz.getSimpleName() + " {"); + lines.add(""); + lines.add(" @Child private CalleeContext calleeContext = CalleeContext.create();"); + lines.add(" @Child private BoundaryCallData boundaryCallData;"); + lines.add(" @Child private GetThreadStateNode getThreadStateNode = GetThreadStateNode.create();"); + for (int j = 0; j < wrapper.argumentTypes.size(); j++) { + TypeMirror argConversionClass = wrapper.argumentTypes.get(j); + + VariableElement formalParameter = formalParameters.get(j + 2); + Name formalParameterName = formalParameter.getSimpleName(); + String convertNodeName = "convert" + formalParameterName; + if (needsConversion(argConversionClass)) { + TypeElement argConversionClassTypeElement = (TypeElement) typeUtils.asElement(argConversionClass); + classesToImport.add(argConversionClassTypeElement.getQualifiedName()); + Name simpleName = argConversionClassTypeElement.getSimpleName(); + ExecutableElement createMethod = findMethod(wrapper.origin, argConversionClass, "create", argConversionClass); + String createMethodName = createMethod != null ? createMethod.getSimpleName().toString() : "null"; + lines.add(String.format(" @Child private %s %s = %s.%s();", simpleName, convertNodeName, simpleName, createMethodName)); + + /* + * TODO: Reliably determine the expected type for the actual parameter. + * + * This is about the required type for the actual parameter for the call of + * `ExternalFunctionInvoker.invoke*`. The required parameter type should be + * inferred from the formal parameter type of the invoke method. Since those + * methods are generated in the same go, we cannot rely on them being already + * available. However, we know how they are generated in + * `generateExternalFunctionInvoker` and we could use that. For this, we will + * need table `externalFunctionSignatures`. + */ + TypeMirror expectedActualType = toJavaNfiType(formalParameter.asType()); + + ExecutableElement executeMethod = findMethod(wrapper.origin, argConversionClass, "execute", expectedActualType, formalParameter.asType()); + String executeMethodName = executeMethod != null ? executeMethod.getSimpleName().toString() : "null"; + if (executeMethod != null) { + /* + * Also already generate the expression that invokes the Python-to-native + * conversion node. + */ + cArgs.add(String.format("%s.%s(%s)", convertNodeName, executeMethodName, formalParameterName)); + } else { + errorOccurred = true; + } + } else { + // If no conversion is required, then just pass the formal parameter. + cArgs.add(formalParameterName.toString()); + } + + if (needsReachabilityFence(formalParameter.asType())) { + needReachabilityFence.add(formalParameter); + } + } + lines.add(""); + lines.add(" private final CApiTiming timing;"); + lines.add(""); + lines.add(" public " + genClassName + "(PythonLanguage language, TruffleString name, PExternalFunctionWrapper wrapper) {"); + lines.add(" super(language, name, wrapper);"); + lines.add(" this.timing = CApiTiming.create(true, name);"); + lines.add(" this.boundaryCallData = BoundaryCallData.createFor(this);"); + lines.add(" }"); + lines.add(""); + + lines.add(" @Override"); + lines.add(" protected " + getSimpleName(wrapper.origin.getReturnType()) + " invokeExternalFunction(" + String.join(", ", methodInvokeFormalArgs) + ") {"); + lines.add(" PythonContext context = PythonContext.get(this);"); + + String returnStmt = isVoidReturn ? "" : "return "; + lines.add(" try {"); + if (errorOccurred) { + lines.add(" throw new RuntimeException(\"error occurred during generation\");"); + } else { + lines.add(" " + returnStmt + EXFUNC_INVOKER_CLASS_NAME + "." + "invoke" + wrapper.signature + "(" + String.join(", ", cArgs) + ");"); + } + lines.add(" } finally {"); + for (VariableElement formalParameter : needReachabilityFence) { + lines.add(String.format(" Reference.reachabilityFence(%s);", formalParameter.getSimpleName())); + } + lines.add(" }"); + + lines.add(" }"); + lines.add(" }"); + } + + for (Name classToImport : classesToImport) { + lines.add(importMarker++, String.format("import %s;", classToImport)); + } + + // generate factory method + lines.add(" @TruffleBoundary"); + lines.add(" public static WrapperDescriptorRoot create(PythonLanguage language, TruffleString name, PExternalFunctionWrapper wrapper) {"); + lines.add(" return switch (wrapper) {"); + for (CApiExternalFunctionWrapperDesc wrapper : wrappers) { + String wrapperList = wrapper.wrapperNames.stream().map(CApiBuiltinsProcessor::name).collect(Collectors.joining(", ")); + lines.add(" case " + wrapperList + " -> new " + name(wrapper.origin) + "Gen(language, name, wrapper);"); + } + lines.add(" default -> throw CompilerDirectives.shouldNotReachHere(\"no root node for wrapper \" + wrapper);"); + lines.add(" };"); + lines.add(" }"); + + // closing brace for WRAPPER_DESCRIPTOR_GEN_CLASS_NAME + lines.add("}"); + + var origins = wrapperInvokeDescs.stream().map((desc) -> desc.origin).toArray(Element[]::new); + var file = processingEnv.getFiler().createSourceFile(EXFUNC_INVOKER_PACKAGE + "." + WRAPPER_DESCRIPTOR_GEN_CLASS_NAME, origins); + try (var w = file.openWriter()) { + w.append(String.join(System.lineSeparator(), lines)); + } + } + @Override @SuppressWarnings({"try", "unused"}) public boolean process(Set annotations, RoundEnvironment re) { @@ -856,11 +2185,38 @@ public boolean process(Set annotations, RoundEnvironment allBuiltins.add(entry); } } - Collections.sort(allBuiltins, (a, b) -> a.name.compareTo(b.name)); + allBuiltins.sort((a, b) -> a.name.compareTo(b.name)); List constants = new ArrayList<>(); List fields = new ArrayList<>(); List structs = new ArrayList<>(); + List javaConstants = new ArrayList<>(); + List externalFunctionSignatures = new ArrayList<>(); + for (var el : re.getElementsAnnotatedWith(CApiConstant.class)) { + if (el.getKind() == ElementKind.FIELD && el.asType().getKind().isPrimitive() && + el.getModifiers().contains(Modifier.STATIC) && el.getModifiers().contains(Modifier.FINAL)) { + VariableElement constant = (VariableElement) el; + Object value = constant.getConstantValue(); + String cValue = value == null ? null : formatCConstantValue(constant, value); + if (cValue != null) { + javaConstants.add(new CApiConstantDesc(constant, constant.getSimpleName().toString(), cValue)); + } else { + processingEnv.getMessager().printError(CApiConstant.class.getSimpleName() + + " is only applicable for Java primitive compile-time constants with C-representable values.", el); + } + } else { + processingEnv.getMessager().printError(CApiConstant.class.getSimpleName() + + " is only applicable for static final Java primitive fields.", el); + } + } + javaConstants.sort((a, b) -> a.name.compareTo(b.name)); + for (int i = 1; i < javaConstants.size(); i++) { + if (javaConstants.get(i - 1).name.equals(javaConstants.get(i).name)) { + processingEnv.getMessager().printError("Duplicate " + CApiConstant.class.getSimpleName() + + " name: " + javaConstants.get(i).name, + javaConstants.get(i).origin); + } + } for (var el : re.getElementsAnnotatedWith(CApiConstants.class)) { if (el.getKind() == ElementKind.ENUM) { for (var enumBit : el.getEnclosedElements()) { @@ -874,7 +2230,7 @@ public boolean process(Set annotations, RoundEnvironment } for (var el : re.getElementsAnnotatedWith(CApiFields.class)) { if (el.getKind() != ElementKind.ENUM) { - processingEnv.getMessager().printError(CApiConstants.class.getSimpleName() + " is only applicable for enums.", el); + processingEnv.getMessager().printError(CApiFields.class.getSimpleName() + " is only applicable for enums.", el); } else { for (var enumBit : el.getEnclosedElements()) { if (enumBit.getKind() == ElementKind.ENUM_CONSTANT) { @@ -885,7 +2241,7 @@ public boolean process(Set annotations, RoundEnvironment } for (var el : re.getElementsAnnotatedWith(CApiStructs.class)) { if (el.getKind() != ElementKind.ENUM) { - processingEnv.getMessager().printError(CApiConstants.class.getSimpleName() + " is only applicable for enums.", el); + processingEnv.getMessager().printError(CApiStructs.class.getSimpleName() + " is only applicable for enums.", el); } else { for (var enumBit : el.getEnclosedElements()) { if (enumBit.getKind() == ElementKind.ENUM_CONSTANT) { @@ -894,17 +2250,46 @@ public boolean process(Set annotations, RoundEnvironment } } } + List explicitUpcallTargets = new LinkedList<>(); + for (var el : re.getElementsAnnotatedWith(CApiUpcallTarget.class)) { + if (el.getKind() == ElementKind.METHOD) { + explicitUpcallTargets.add((ExecutableElement) el); + } else { + processingEnv.getMessager().printError(CApiUpcallTarget.class.getSimpleName() + " is only applicable for methods.", el); + } + } + Map sigs = new HashMap<>(); + for (var el : re.getElementsAnnotatedWith(CApiExternalFunctionSignatures.class)) { + if (el.getKind() == ElementKind.ENUM) { + for (var enumBit : el.getEnclosedElements()) { + if (enumBit.getKind() == ElementKind.ENUM_CONSTANT) { + CApiExternalFunctionSignatureDesc value = new CApiExternalFunctionSignatureDesc((VariableElement) enumBit, enumBit.getSimpleName().toString()); + sigs.put(value.name, value); + } + } + } else { + processingEnv.getMessager().printError(CApiExternalFunctionSignatures.class.getSimpleName() + " is only applicable for enums.", el); + } + } + List cApiExternalFunctionWrapperDescs = new LinkedList<>(); + List externalFunctionDescs = collectExternalFunctionAndWrapperDescs(re, cApiExternalFunctionWrapperDescs); if (allBuiltins.isEmpty()) { return true; } try { + generateNativeAccessSupport(allBuiltins.stream().map((builtin) -> builtin.origin).toArray(Element[]::new)); if (trees != null) { // needs jdk.compiler - generateCApiSource(allBuiltins, constants, fields, structs); - generateCApiHeader(javaBuiltins); + List capiSymbols = collectNativeCAPISymbols(sigs); + generateCApiSource(allBuiltins, constants, fields, structs, capiSymbols); + generateCApiHeader(javaBuiltins, javaConstants, capiSymbols); + generateExternalFunctionInvoker(new ArrayList<>(sigs.values())); + generateExternalFunctionHelperNodes(externalFunctionDescs); + generateExternalFunctionRootNodes(externalFunctionDescs, cApiExternalFunctionWrapperDescs, sigs); } generateBuiltinRegistry(javaBuiltins); + generateUpcallConfig(javaBuiltins, explicitUpcallTargets); generateCApiAsserts(allBuiltins); if (trees != null) { // needs jdk.compiler diff --git a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/GenerateNativeDowncallsProcessor.java b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/GenerateNativeDowncallsProcessor.java new file mode 100644 index 0000000000..ede35d6f5f --- /dev/null +++ b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/GenerateNativeDowncallsProcessor.java @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.processor; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.RoundEnvironment; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.ExecutableElement; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.tools.Diagnostic.Kind; + +import com.oracle.graal.python.annotations.DowncallSignature; +import com.oracle.graal.python.annotations.NativeSimpleType; + +public class GenerateNativeDowncallsProcessor extends AbstractProcessor { + private record NativeDowncallDesc(String name, String symbolName, NativeSimpleType returnType, List argumentTypes, List argumentNames) { + } + + @Override + public Set getSupportedAnnotationTypes() { + return Set.of(DowncallSignature.class.getName()); + } + + @Override + public SourceVersion getSupportedSourceVersion() { + return SourceVersion.latestSupported(); + } + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + if (roundEnv.processingOver()) { + return true; + } + try { + doProcess(roundEnv); + } catch (IOException ex) { + ex.printStackTrace(); + } catch (ProcessingError ex) { + processingEnv.getMessager().printMessage(Kind.ERROR, ex.getMessage(), ex.getElement()); + } + return true; + } + + private void doProcess(RoundEnvironment roundEnv) throws IOException, ProcessingError { + Set invokerElements = new LinkedHashSet<>(); + for (Element element : roundEnv.getElementsAnnotatedWith(DowncallSignature.class)) { + invokerElements.add(validateDowncallSignature(element)); + } + for (TypeElement invokerElement : invokerElements) { + generateInvoker(invokerElement); + } + } + + private static TypeElement validateDowncallSignature(Element element) throws ProcessingError { + if (element.getKind() != ElementKind.METHOD) { + throw error(element, "@DowncallSignature can only annotate methods"); + } + Element enclosingElement = element.getEnclosingElement(); + if (enclosingElement == null || enclosingElement.getKind() != ElementKind.CLASS) { + throw error(element, "@DowncallSignature can only annotate methods in classes"); + } + if (!enclosingElement.getModifiers().contains(Modifier.ABSTRACT)) { + throw error(enclosingElement, "@DowncallSignature methods must be enclosed in an abstract class"); + } + if (!element.getModifiers().contains(Modifier.ABSTRACT)) { + throw error(element, "@DowncallSignature methods must be abstract"); + } + return (TypeElement) enclosingElement; + } + + private void generateInvoker(TypeElement invokerElement) throws IOException, ProcessingError { + List downcalls = collectDowncalls(invokerElement); + if (downcalls.isEmpty()) { + throw error(invokerElement, "Annotated class does not declare any downcalls"); + } + + String packageName = processingEnv.getElementUtils().getPackageOf(invokerElement).getQualifiedName().toString(); + String invokerQualifiedName = invokerElement.getQualifiedName().toString(); + String invokerTypeRef = invokerQualifiedName.startsWith(packageName + ".") ? invokerQualifiedName.substring(packageName.length() + 1) : invokerQualifiedName; + String className = invokerElement.getSimpleName() + "Gen"; + + ArrayList lines = new ArrayList<>(); + lines.add("// @formatter:off"); + lines.add("// Checkstyle: stop"); + lines.add("// Generated by annotation processor: " + getClass().getName()); + lines.add("package " + packageName + ";"); + lines.add(""); + lines.add("import java.lang.invoke.MethodHandle;"); + lines.add("import java.lang.invoke.MethodType;"); + lines.add("import java.util.concurrent.atomic.AtomicLongArray;"); + lines.add(""); + lines.add("import com.oracle.graal.python.runtime.nativeaccess.NativeAccessSupport;"); + lines.add("import com.oracle.graal.python.runtime.nativeaccess.NativeLibrary;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives;"); + lines.add("import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;"); + lines.add(""); + lines.add("final class " + className + " extends " + invokerTypeRef + " {"); + lines.add(" private final PythonContext context;"); + lines.add(" private final AtomicLongArray cachedFunctions = new AtomicLongArray(" + downcalls.size() + ");"); + lines.add(" private volatile NativeLibrary nativeLibrary;"); + lines.add(""); + + for (NativeDowncallDesc downcall : downcalls) { + NativeDowncallMethodHandleGenerator.emitMethodHandleField(lines, methodHandleName(downcall.name), downcall.returnType, downcall.argumentTypes); + } + + lines.add(""); + lines.add(" " + className + "(PythonContext context) {"); + lines.add(" this.context = context;"); + lines.add(" }"); + + for (int i = 0; i < downcalls.size(); i++) { + emitDowncallMethod(lines, downcalls.get(i), i); + } + + lines.add(""); + lines.add(" @TruffleBoundary"); + lines.add(" private long lookup(int functionIndex, String symbolName) {"); + lines.add(" long symbol = cachedFunctions.get(functionIndex);"); + lines.add(" if (symbol == 0) {"); + lines.add(" symbol = loadFunction(symbolName);"); + lines.add(" cachedFunctions.compareAndSet(functionIndex, 0, symbol);"); + lines.add(" symbol = cachedFunctions.get(functionIndex);"); + lines.add(" }"); + lines.add(" return symbol;"); + lines.add(" }"); + lines.add(""); + lines.add(" @TruffleBoundary"); + lines.add(" private long loadFunction(String symbolName) {"); + lines.add(" return ensureLibrary().lookupSymbol(symbolName);"); + lines.add(" }"); + lines.add(""); + lines.add(" @TruffleBoundary"); + lines.add(" private NativeLibrary ensureLibrary() {"); + lines.add(" NativeLibrary library = nativeLibrary;"); + lines.add(" if (library == null) {"); + lines.add(" library = " + invokerTypeRef + ".loadNativeLibrary(context);"); + lines.add(" nativeLibrary = library;"); + lines.add(" }"); + lines.add(" return library;"); + lines.add(" }"); + lines.add("}"); + + var file = processingEnv.getFiler().createSourceFile(packageName + "." + className, invokerElement); + try (var writer = file.openWriter()) { + writer.append(String.join(System.lineSeparator(), lines)); + } + } + + private static List collectDowncalls(TypeElement invokerElement) throws ProcessingError { + List result = new ArrayList<>(); + Set methodNames = new java.util.HashSet<>(); + for (Element enclosedElement : invokerElement.getEnclosedElements()) { + if (enclosedElement.getKind() == ElementKind.METHOD && enclosedElement.getAnnotation(DowncallSignature.class) != null) { + NativeDowncallDesc downcall = extractDowncall((ExecutableElement) enclosedElement); + if (!methodNames.add(downcall.name)) { + throw error(enclosedElement, "Duplicate downcall method name: %s", downcall.name); + } + result.add(downcall); + } + } + return result; + } + + private static NativeDowncallDesc extractDowncall(ExecutableElement method) throws ProcessingError { + DowncallSignature annotation = method.getAnnotation(DowncallSignature.class); + if (annotation == null) { + throw error(method, "Downcall method must be annotated with @DowncallSignature"); + } + + NativeSimpleType[] argTypes = annotation.argumentTypes(); + if (argTypes.length != method.getParameters().size()) { + throw error(method, "@DowncallSignature argumentTypes length must match method parameter count (%d != %d)", argTypes.length, method.getParameters().size()); + } + validateJavaType(method, method.getReturnType(), annotation.returnType()); + for (int i = 0; i < argTypes.length; i++) { + validateJavaType(method.getParameters().get(i), method.getParameters().get(i).asType(), argTypes[i]); + } + + List argumentTypes = List.of(argTypes); + List argumentNames = extractArgumentNames(method); + String symbolName = method.getSimpleName().toString(); + return new NativeDowncallDesc( + symbolName, + symbolName, + annotation.returnType(), + argumentTypes, + argumentNames); + } + + private static List extractArgumentNames(ExecutableElement method) throws ProcessingError { + List result = new ArrayList<>(method.getParameters().size()); + for (VariableElement parameter : method.getParameters()) { + String argName = parameter.getSimpleName().toString(); + if (argName.isBlank()) { + throw error(parameter, "Downcall parameter name must not be blank"); + } + if (!SourceVersion.isIdentifier(argName) || SourceVersion.isKeyword(argName)) { + throw error(parameter, "Downcall parameter name is not a valid Java identifier: %s", argName); + } + result.add(argName); + } + return result; + } + + private static void validateJavaType(Element element, TypeMirror actualType, NativeSimpleType nativeType) throws ProcessingError { + TypeKind expected = switch (nativeType) { + case VOID -> TypeKind.VOID; + case SINT8 -> TypeKind.BYTE; + case SINT16 -> TypeKind.SHORT; + case SINT32 -> TypeKind.INT; + case SINT64, POINTER -> TypeKind.LONG; + case FLOAT -> TypeKind.FLOAT; + case DOUBLE -> TypeKind.DOUBLE; + }; + if (actualType.getKind() != expected) { + throw error(element, "Java type %s does not match native type %s", actualType, nativeType); + } + } + + private static ProcessingError error(Element element, String fmt, Object... args) throws ProcessingError { + throw new ProcessingError(element, fmt, args); + } + + private static String nativeSimpleTypeToJavaType(NativeSimpleType type) { + return switch (type) { + case VOID -> "void"; + case SINT8 -> "byte"; + case SINT16 -> "short"; + case SINT32 -> "int"; + case SINT64, POINTER -> "long"; + case FLOAT -> "float"; + case DOUBLE -> "double"; + }; + } + + private static void emitDowncallMethod(List lines, NativeDowncallDesc downcall, int functionIndex) { + lines.add(""); + lines.add(" @TruffleBoundary(allowInlining = true, transferToInterpreterOnException = false)"); + lines.add(" @Override"); + lines.add(" " + nativeSimpleTypeToJavaType(downcall.returnType) + " " + downcall.name + "(" + typedArgs(downcall.argumentTypes, downcall.argumentNames) + ") {"); + lines.add(" long functionPointer = lookup(" + functionIndex + ", " + stringLiteral(downcall.symbolName) + ");"); + lines.add(" try {"); + if (NativeSimpleType.VOID == downcall.returnType) { + lines.add(" " + methodHandleName(downcall.name) + ".invokeExact(" + invokeArgs(downcall.argumentNames) + ");"); + } else { + lines.add(" return (" + nativeSimpleTypeToJavaType(downcall.returnType) + ") " + methodHandleName(downcall.name) + ".invokeExact(" + invokeArgs(downcall.argumentNames) + ");"); + } + lines.add(" } catch (Throwable t) {"); + lines.add(" throw CompilerDirectives.shouldNotReachHere(t);"); + lines.add(" }"); + lines.add(" }"); + } + + private static String methodHandleName(String downcallName) { + return NativeDowncallMethodHandleGenerator.methodHandleVarName(downcallName.toUpperCase()); + } + + private static String typedArgs(List argTypes, List argNames) { + List args = new ArrayList<>(argTypes.size()); + for (int i = 0; i < argTypes.size(); i++) { + args.add(nativeSimpleTypeToJavaType(argTypes.get(i)) + " " + argNames.get(i)); + } + return String.join(", ", args); + } + + private static String invokeArgs(List argNames) { + String args = String.join(", ", argNames); + return args.isEmpty() ? "functionPointer" : "functionPointer, " + args; + } + + private static String stringLiteral(String value) { + return "\"" + value.replace("\\", "\\\\").replace("\"", "\\\"") + "\""; + } +} diff --git a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/NativeDowncallMethodHandleGenerator.java b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/NativeDowncallMethodHandleGenerator.java new file mode 100644 index 0000000000..e31e059c70 --- /dev/null +++ b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/NativeDowncallMethodHandleGenerator.java @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.processor; + +import java.util.ArrayList; +import java.util.List; + +import com.oracle.graal.python.annotations.NativeSimpleType; + +final class NativeDowncallMethodHandleGenerator { + private NativeDowncallMethodHandleGenerator() { + } + + static String argName(int i) { + if (i >= 26) { + throw new IllegalArgumentException("Generated downcall stubs support at most 26 synthetic argument names (a-z), got index " + i); + } + return "" + (char) ('a' + i); + } + + static String methodHandleVarName(String signatureName) { + return "NATIVE_METHOD_HANDLE_" + signatureName; + } + + static String toClassLiteral(String javaType) { + return switch (javaType) { + case "void" -> "void.class"; + case "byte" -> "byte.class"; + case "short" -> "short.class"; + case "int" -> "int.class"; + case "long" -> "long.class"; + case "float" -> "float.class"; + case "double" -> "double.class"; + default -> throw new IllegalArgumentException("Unexpected Java type: " + javaType); + }; + } + + static String toClassLiteral(NativeSimpleType nativeType) { + return switch (nativeType) { + case VOID -> "void.class"; + case SINT8 -> "byte.class"; + case SINT16 -> "short.class"; + case SINT32 -> "int.class"; + case SINT64, POINTER -> "long.class"; + case FLOAT -> "float.class"; + case DOUBLE -> "double.class"; + }; + } + + static void emitMethodHandleField(List lines, String fieldName, String returnType, List argTypes) { + List methodTypeArgs = new ArrayList<>(); + methodTypeArgs.add("long.class"); + for (String argType : argTypes) { + methodTypeArgs.add(toClassLiteral(argType)); + } + lines.add(" private static final MethodHandle " + fieldName + " = NativeAccessSupport.createDowncallHandle(" + + "MethodType.methodType(" + toClassLiteral(returnType) + ", " + String.join(", ", methodTypeArgs) + "), false);"); + } + + static void emitMethodHandleField(List lines, String fieldName, NativeSimpleType returnType, List argTypes) { + List methodTypeArgs = new ArrayList<>(); + methodTypeArgs.add("long.class"); + for (NativeSimpleType argType : argTypes) { + methodTypeArgs.add(toClassLiteral(argType)); + } + lines.add(" private static final MethodHandle " + fieldName + " = NativeAccessSupport.createDowncallHandle(" + + "MethodType.methodType(" + toClassLiteral(returnType) + ", " + String.join(", ", methodTypeArgs) + "), false);"); + } +} diff --git a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/SlotsMapping.java b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/SlotsMapping.java index d9a12cbd5f..9146b21882 100644 --- a/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/SlotsMapping.java +++ b/graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/SlotsMapping.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -51,7 +51,7 @@ private static String getSuffix(boolean isComplex) { static String getSlotBaseClass(Slot s) { return switch (s.value()) { - case nb_bool -> "TpSlotInquiry.TpSlotInquiryBuiltin"; + case nb_bool -> "TpSlotInquiry.TpSlotInquiryBuiltin" + getSuffix(s.isComplex()); case nb_index, nb_int, nb_float, nb_absolute, nb_positive, nb_negative, nb_invert, tp_iter, tp_str, tp_repr, am_aiter, am_anext, am_await -> "TpSlotUnaryFunc.TpSlotUnaryFuncBuiltin"; @@ -128,10 +128,7 @@ static String getUncachedExecuteSignature(SlotKind s) { } static boolean supportsComplex(SlotKind s) { - return switch (s) { - case nb_bool -> false; - default -> true; - }; + return true; } static boolean supportsSimple(SlotKind s) { diff --git a/graalpython/com.oracle.graal.python.resources/pom.xml b/graalpython/com.oracle.graal.python.resources/pom.xml new file mode 100644 index 0000000000..ce411c3713 --- /dev/null +++ b/graalpython/com.oracle.graal.python.resources/pom.xml @@ -0,0 +1,69 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.resources + jar + + + + org.graalvm.truffle + truffle-api + + + org.graalvm.truffle + truffle-dsl-processor + provided + true + + + diff --git a/graalpython/com.oracle.graal.python.resources/src/com/oracle/graal/python/resources/PythonResource.java b/graalpython/com.oracle.graal.python.resources/src/com/oracle/graal/python/resources/PythonResource.java index 5cbc89262a..4b76ac03e2 100644 --- a/graalpython/com.oracle.graal.python.resources/src/com/oracle/graal/python/resources/PythonResource.java +++ b/graalpython/com.oracle.graal.python.resources/src/com/oracle/graal/python/resources/PythonResource.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -43,6 +43,7 @@ import java.io.File; import java.io.IOException; import java.io.InputStream; +import java.nio.charset.StandardCharsets; import java.nio.file.InvalidPathException; import java.nio.file.Path; import java.util.ArrayList; @@ -66,6 +67,7 @@ public final class PythonResource implements InternalResource { private static final int PYTHON_MINOR; private static final int GRAALVM_MAJOR; private static final int GRAALVM_MINOR; + private static final String PYTHON_ABIFLAGS; /** * The version generated at build time is stored in an ASCII-compatible way. Add build time, we @@ -82,6 +84,13 @@ public final class PythonResource implements InternalResource { is.read(); // skip python micro version GRAALVM_MAJOR = is.read() - VERSION_BASE; GRAALVM_MINOR = is.read() - VERSION_BASE; + is.read(); // skip GraalVM micro version + is.read(); // skip release level + int ch; + while ((ch = is.read()) != '\n' && ch != -1) { + // skip ABI version + } + PYTHON_ABIFLAGS = ch == -1 ? "" : new String(is.readAllBytes(), StandardCharsets.US_ASCII).strip(); } catch (IOException e) { throw new RuntimeException(e); } @@ -105,7 +114,8 @@ public final class PythonResource implements InternalResource { @Override public void unpackFiles(Env env, Path targetDirectory) throws IOException { OS os = env.getOS(); - Path osArch = Path.of(os.toString()).resolve(env.getCPUArchitecture().toString()); + CPUArchitecture cpuArchitecture = env.getCPUArchitecture(); + Path osArch = Path.of(os.toString()).resolve(cpuArchitecture.toString()); ResourcesFilter filter = new ResourcesFilter(); if (os.equals(OS.WINDOWS)) { env.unpackResourceFiles(BASE_PATH.resolve(LIBPYTHON_FILES), targetDirectory.resolve("Lib"), BASE_PATH.resolve(LIBPYTHON), filter); @@ -116,12 +126,28 @@ public void unpackFiles(Env env, Path targetDirectory) throws IOException { env.unpackResourceFiles(BASE_PATH.resolve(LIBPYTHON_FILES), targetDirectory.resolve("lib").resolve(pythonMajMin), BASE_PATH.resolve(LIBPYTHON), filter); env.unpackResourceFiles(BASE_PATH.resolve(LIBGRAALPY_FILES), targetDirectory.resolve("lib").resolve("graalpy" + GRAALVM_MAJOR + "." + GRAALVM_MINOR), BASE_PATH.resolve(LIBGRAALPY), filter); - env.unpackResourceFiles(BASE_PATH.resolve(INCLUDE_FILES), targetDirectory.resolve("include").resolve(pythonMajMin), BASE_PATH.resolve(INCLUDE), filter); + env.unpackResourceFiles(BASE_PATH.resolve(INCLUDE_FILES), targetDirectory.resolve("include").resolve(pythonMajMin + PYTHON_ABIFLAGS), BASE_PATH.resolve(INCLUDE), filter); } // ni files are in the same place on all platforms env.unpackResourceFiles(BASE_PATH.resolve(NI_FILES), targetDirectory, BASE_PATH, filter); // native files already have the correct structure - env.unpackResourceFiles(BASE_PATH.resolve(osArch).resolve(NATIVE_FILES), targetDirectory, BASE_PATH.resolve(osArch), filter); + if (!os.equals(OS.UNSUPPORTED) && !cpuArchitecture.equals(CPUArchitecture.UNSUPPORTED)) { + env.unpackResourceFiles(BASE_PATH.resolve(osArch).resolve(NATIVE_FILES), targetDirectory, BASE_PATH.resolve(osArch), filter); + } else { + // Native resources are not available for unsupported operating systems. + if (!filter.test(Path.of(NATIVE_FILES))) { + throw new IOException("Extracting native resources failed for " + + osArch.toString() + + ". This means that GraalPy cannot use native extensions and some built-in features that rely on native code will be unavailable. " + + "Currently supported platforms are linux/amd64, linux/aarch64, macos/aarch64, and windows/amd64. " + + "If you are running on one of these platforms and are receiving this error, that indicates a bug in this build of GraalPy. " + + "If you are running on a different platform and want to keep going with this unsupported configuration, you can specify the system property \"" + + ResourcesFilter.EXCLUDE_PROP + + "\" with a pattern to exclude \"" + + NATIVE_FILES + + "\" to continue past this point. "); + } + } if (filter.log) { System.out.println("unpacked python resources:"); @@ -153,8 +179,7 @@ private static class ResourcesFilter implements Predicate { private final List included; private static final String INCLUDE_PROP = "org.graalvm.python.resources.include"; private static final String EXCLUDE_PROP = "org.graalvm.python.resources.exclude"; - - private static final String LOG_PROP = "org.graalvm.python.resources.exclude"; + private static final String LOG_PROP = "org.graalvm.python.resources.log"; private ResourcesFilter() { include = getProperty(INCLUDE_PROP); @@ -211,7 +236,14 @@ private static String getProperty(String prop) { @Override public String versionHash(Env env) { StringBuilder sb = new StringBuilder(); - for (var s : List.of(LIBGRAALPY_SHA256, LIBPYTHON_SHA256, NI_SHA256, INCLUDE_SHA256, Path.of(env.getOS().toString()).resolve(env.getCPUArchitecture().toString()).resolve(NATIVE_SHA256))) { + List al = List.of(LIBGRAALPY_SHA256, LIBPYTHON_SHA256, NI_SHA256, INCLUDE_SHA256); + OS os = env.getOS(); + CPUArchitecture cpuArchitecture = env.getCPUArchitecture(); + if (!os.equals(OS.UNSUPPORTED) && !cpuArchitecture.equals(CPUArchitecture.UNSUPPORTED)) { + al = new ArrayList<>(al); + al.add(Path.of(os.toString()).resolve(cpuArchitecture.toString()).resolve(NATIVE_SHA256)); + } + for (var s : al) { try { sb.append(env.readResourceLines(BASE_PATH.resolve(s)).get(0).substring(0, 8)); } catch (IOException | IndexOutOfBoundsException | InvalidPathException e) { diff --git a/graalpython/com.oracle.graal.python.shell/pom.xml b/graalpython/com.oracle.graal.python.shell/pom.xml new file mode 100644 index 0000000000..c086fee5f2 --- /dev/null +++ b/graalpython/com.oracle.graal.python.shell/pom.xml @@ -0,0 +1,75 @@ + + + + 4.0.0 + + + org.graalvm.python.ide + graalpy-source-workspace + 1.0-SNAPSHOT + ../../pom.xml + + + com.oracle.graal.python.shell + jar + + + + org.graalvm.polyglot + polyglot + + + org.graalvm.sdk + launcher-common + + + org.graalvm.shadowed + jline + + + org.graalvm.sdk + maven-downloader + + + diff --git a/graalpython/com.oracle.graal.python.shell/src/META-INF/native-image/org.graalvm.python.shell/python-launcher/reflect-config.json b/graalpython/com.oracle.graal.python.shell/src/META-INF/native-image/org.graalvm.python.shell/python-launcher/reflect-config.json new file mode 100644 index 0000000000..d57e806bbb --- /dev/null +++ b/graalpython/com.oracle.graal.python.shell/src/META-INF/native-image/org.graalvm.python.shell/python-launcher/reflect-config.json @@ -0,0 +1,27 @@ +[ + { + "name": "com.oracle.graal.python.shell.JLineConsoleHandler", + "methods": [ + { + "name": "initializeReadline", + "parameterTypes": [ + "org.graalvm.polyglot.Value" + ] + }, + { + "name": "readLine", + "parameterTypes": [ + "java.lang.String" + ] + }, + { + "name": "getCompletionState", + "parameterTypes": [] + } + ] + }, + { + "name": "com.oracle.graal.python.shell.JLineConsoleHandler$CompletionState", + "allPublicFields": true + } +] diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java index 2ef70934fb..70753e3a61 100644 --- a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java +++ b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,46 +40,16 @@ */ package com.oracle.graal.python.shell; -import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; -import java.util.List; -import java.util.function.BiConsumer; -import java.util.function.BooleanSupplier; -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.IntConsumer; -import java.util.function.IntFunction; -import java.util.function.IntSupplier; - -import org.graalvm.polyglot.Context; /** * The interface to a source of input/output for the context, which may have different * implementations for different contexts. */ -abstract class ConsoleHandler { - - /** - * Read a line of input, newline is NOT included in result. - */ - public final String readLine() { - return readLine(true); - } - - public abstract String readLine(boolean prompt); - - public abstract void setPrompt(String prompt); - - public void setContext(@SuppressWarnings("unused") Context context) { - // ignore by default - } +public abstract class ConsoleHandler { - @SuppressWarnings("unused") - public void setupReader(BooleanSupplier shouldRecord, IntSupplier getSize, Consumer addItem, IntFunction getItem, BiConsumer setItem, IntConsumer removeItem, - Runnable clear, Function> completer) { - // ignore by default - } + public abstract String readLine(String prompt); public InputStream createInputStream() { return new InputStream() { @@ -87,13 +57,13 @@ public InputStream createInputStream() { int pos = 0; @Override - public int read() throws IOException { + public int read() { if (pos < 0) { pos = 0; return -1; } else if (buffer == null) { assert pos == 0; - String line = readLine(false); + String line = readLine(null); if (line == null) { return -1; } @@ -109,14 +79,4 @@ public int read() throws IOException { } }; } - - public int getTerminalWidth() { - // default value - return 80; - } - - public int getTerminalHeight() { - // default value - return 25; - } } diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/DefaultConsoleHandler.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/DefaultConsoleHandler.java index 52d68c23f3..60d80c85b5 100644 --- a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/DefaultConsoleHandler.java +++ b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/DefaultConsoleHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -54,7 +54,7 @@ class DefaultConsoleHandler extends ConsoleHandler { } @Override - public String readLine(boolean showPrompt) { + public String readLine(String prompt) { try { return in.readLine(); } catch (IOException e) { @@ -62,7 +62,4 @@ public String readLine(boolean showPrompt) { } } - @Override - public void setPrompt(String prompt) { - } } diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java index 781ec18a3b..5f2ec5e99f 100644 --- a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java +++ b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. * Copyright (c) 2013, Regents of the University of California * * All rights reserved. @@ -34,6 +34,12 @@ import java.io.InputStream; import java.io.OutputStream; import java.lang.management.ManagementFactory; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.CharsetDecoder; +import java.nio.charset.CoderResult; +import java.nio.charset.CodingErrorAction; import java.nio.file.Files; import java.nio.file.InvalidPathException; import java.nio.file.NoSuchFileException; @@ -46,7 +52,6 @@ import java.util.Map; import java.util.Set; import java.util.UUID; -import java.util.function.Function; import java.util.function.Predicate; import org.graalvm.launcher.AbstractLanguageLauncher; @@ -81,6 +86,56 @@ public static void main(String[] args) { new GraalPythonMain().launch(args); } + @Override + protected String decodeArgument(byte[] argument) { + Charset charset = Charset.defaultCharset(); + String decoded = new String(argument, charset); + if (decoded.indexOf('\uFFFD') < 0) { + return decoded; + } + return decodeArgument(argument, charset); + } + + /* + * Match documented Unix sys.argv behavior: + * https://docs.python.org/3.12/library/sys.html#sys.argv + * "When you need original bytes, you can get it by `[os.fsencode(arg) for arg in sys.argv]`." + */ + private static String decodeArgument(byte[] argument, Charset charset) { + CharsetDecoder decoder = charset.newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT); + StringBuilder builder = new StringBuilder(argument.length); + ByteBuffer in = ByteBuffer.wrap(argument); + CharBuffer out = CharBuffer.allocate(Math.max(1, (int) Math.ceil(argument.length * decoder.maxCharsPerByte()))); + while (true) { + CoderResult result = decoder.decode(in, out, true); + appendDecodedChars(builder, out); + if (result.isUnderflow()) { + break; + } else if (result.isOverflow()) { + continue; + } else if (result.isError()) { + int errorLength = result.length(); + for (int i = 0; i < errorLength && in.hasRemaining(); i++) { + builder.append((char) (0xDC00 + (in.get() & 0xff))); + } + } + } + while (true) { + CoderResult result = decoder.flush(out); + appendDecodedChars(builder, out); + if (result.isUnderflow()) { + break; + } + } + return builder.toString(); + } + + private static void appendDecodedChars(StringBuilder builder, CharBuffer out) { + out.flip(); + builder.append(out); + out.clear(); + } + private static final String LANGUAGE_ID = "python"; private static final String J_PYENVCFG = "pyvenv.cfg"; @@ -103,6 +158,7 @@ public static void main(String[] args) { private boolean noSite = false; private boolean unbufferedIO = false; private boolean multiContext = false; + private int repeatedRuns = 1; private boolean snaptshotStartup = false; private boolean warnDefaultEncoding = false; private int intMaxStrDigits = -1; @@ -182,8 +238,11 @@ protected List preprocessArguments(List givenArgs, Map(); boolean posixBackendSpecified = false; boolean sha3BackendSpecified = false; + boolean compressionBackendSpecified = false; + boolean pyExpatBackendSpecified = false; boolean installSignalHandlersSpecified = false; boolean isolateNativeModulesSpecified = false; + boolean jitModePresetSpecified = false; for (Iterator argumentIterator = arguments.iterator(); argumentIterator.hasNext();) { String arg = argumentIterator.next(); origArgs.add(arg); @@ -229,6 +288,9 @@ protected List preprocessArguments(List givenArgs, Map preprocessArguments(List givenArgs, Map preprocessArguments(List givenArgs, Map preprocessArguments(List givenArgs, Map 0) { intMaxStrDigits = validateIntMaxStrDigits(xOption.substring(eq), "-X int_max_str_digits"); } + } else if ("jit".equals(xOption) || xOption.startsWith("jit=")) { + applyJitModePreset(polyglotOptions, xOption); + jitModePresetSpecified = true; } break shortOptionLoop; default: @@ -444,12 +518,21 @@ protected List preprocessArguments(List givenArgs, Map it = origArgs.iterator(); - while (it.hasNext()) { - if (relaunchArgs.contains(it.next())) { - it.remove(); - } - } - } origArgs.add(0, toAbsolutePath(executable)); contextBuilder.option("python.OrigArgv", String.join(STRING_LIST_DELIMITER, origArgs)); @@ -791,9 +866,8 @@ protected void launch(Builder contextBuilder) { ConsoleHandler consoleHandler = createConsoleHandler(System.in, System.out); contextBuilder.arguments(getLanguageId(), programArgs.toArray(new String[programArgs.size()])); contextBuilder.in(consoleHandler.createInputStream()); - contextBuilder.option("python.TerminalIsInteractive", Boolean.toString(isTTY())); - contextBuilder.option("python.TerminalWidth", Integer.toString(consoleHandler.getTerminalWidth())); - contextBuilder.option("python.TerminalHeight", Integer.toString(consoleHandler.getTerminalHeight())); + boolean tty = isTTY(); + contextBuilder.option("python.TerminalIsInteractive", Boolean.toString(tty)); contextBuilder.option("python.CheckHashPycsMode", checkHashPycsMode); contextBuilder.option("python.RunViaLauncher", "true"); @@ -806,83 +880,82 @@ protected void launch(Builder contextBuilder) { contextBuilder.option("python.PyCachePrefix", cachePrefix); } + setOptionIfNotSetViaCommandLine(contextBuilder, "AllowSignalHandlers", "true"); + if (IS_WINDOWS) { contextBuilder.option("python.PosixModuleBackend", "java"); } - if (!hasContextOptionSetViaCommandLine("WarnExperimentalFeatures")) { - contextBuilder.option("python.WarnExperimentalFeatures", "false"); - } + setOptionIfNotSetViaCommandLine(contextBuilder, "WarnExperimentalFeatures", "false"); + setOptionIfNotSetViaCommandLine(contextBuilder, "UnicodeCharacterDatabaseNativeFallback", "true"); if (multiContext) { contextBuilder.engine(Engine.newBuilder().allowExperimentalOptions(true).options(enginePolyglotOptions).build()); } int rc = 1; - try (Context context = contextBuilder.build()) { - runVersionAction(versionAction, context.getEngine()); + for (int i = 0; i < repeatedRuns; i++) { + try (Context context = contextBuilder.build()) { + runVersionAction(versionAction, context.getEngine()); - if (snaptshotStartup) { - evalInternal(context, "__graalpython__.startup_wall_clock_ts = " + startupWallClockTime + "; __graalpython__.startup_nano = " + startupNanoTime); - } + if (snaptshotStartup) { + evalInternal(context, "__graalpython__.startup_wall_clock_ts = " + startupWallClockTime + "; __graalpython__.startup_nano = " + startupNanoTime); + } + + Value sysModule = evalInternal(context, "import sys; sys"); + if (!quietFlag && (verboseFlag || (commandString == null && inputFile == null && tty))) { + print("Python " + sysModule.getMember("version").asString() + " on " + sysModule.getMember("platform")); + if (!noSite) { + print("Type \"help\", \"copyright\", \"credits\" or \"license\" for more information."); + } + } - if (!quietFlag && (verboseFlag || (commandString == null && inputFile == null && isTTY()))) { - print("Python " + evalInternal(context, "import sys; sys.version + ' on ' + sys.platform").asString()); - if (!noSite) { - print("Type \"help\", \"copyright\", \"credits\" or \"license\" for more information."); + sysModule.putMember("_console_handler", consoleHandler); + if (tty && !isolateFlag && (inspectFlag || (commandString == null && inputFile == null))) { + evalInternal(context, "import readline, rlcompleter"); } - } - consoleHandler.setContext(context); - if (commandString != null || inputFile != null || !isTTY()) { - try { - evalNonInteractive(context, consoleHandler); - rc = 0; - } catch (PolyglotException e) { - if (e.isExit()) { - rc = e.getExitStatus(); - } else { - throw e; + if (commandString != null || inputFile != null || !tty) { + try { + evalNonInteractive(context, consoleHandler); + rc = 0; + } catch (PolyglotException e) { + if (e.isExit()) { + rc = e.getExitStatus(); + } else { + throw e; + } + } catch (NoSuchFileException e) { + printFileNotFoundException(e); } - } catch (NoSuchFileException e) { - printFileNotFoundException(e); } - } - if ((commandString == null && inputFile == null) || inspectFlag) { - inspectFlag = false; - rc = readEvalPrint(context, consoleHandler); - } - } catch (RuntimeException e) { - if (e.getMessage() != null && e.getMessage().contains("did not complete all polyglot threads")) { - // Python may end up with stuck threads and code would legitimately expect those to - // simply die with the process. In an embedding (or CPython subinterpreters) this - // is a problem, so Truffle throws an IllegalStateException when closing the - // context if that occurs. But here we have a launcher and usually we do not care - // about this problem during exit. For an example and some discussion, see - // https://discuss.python.org/t/getting-rid-of-daemon-threads/68836/14 where NJS - // brings up getaddrinfo which may just block in native for an arbitrary amount of - // time and prevent us from shutting down the thread. - if (!verboseFlag) { - tryToResetConsoleHandler(consoleHandler); - System.exit(rc); + if ((tty && commandString == null && inputFile == null) || inspectFlag) { + inspectFlag = false; + rc = readEvalPrint(context, consoleHandler, sysModule); } - } else { - throw e; + } catch (RuntimeException e) { + if (e.getMessage() != null && e.getMessage().contains("did not complete all polyglot threads")) { + // Python may end up with stuck threads and code would legitimately expect those to + // simply die with the process. In an embedding (or CPython subinterpreters) this + // is a problem, so Truffle throws an IllegalStateException when closing the + // context if that occurs. But here we have a launcher and usually we do not care + // about this problem during exit. For an example and some discussion, see + // https://discuss.python.org/t/getting-rid-of-daemon-threads/68836/14 where NJS + // brings up getaddrinfo which may just block in native for an arbitrary amount of + // time and prevent us from shutting down the thread. + if (!verboseFlag) { + System.exit(rc); + } + } else { + throw e; + } + } catch (IOException e) { + rc = 1; + e.printStackTrace(); + } + if (rc != 0) { + System.exit(rc); } - } catch (IOException e) { - rc = 1; - e.printStackTrace(); - } finally { - tryToResetConsoleHandler(consoleHandler); - } - System.exit(rc); - } - - private static void tryToResetConsoleHandler(ConsoleHandler consoleHandler) { - try { - consoleHandler.setContext(null); - } catch (Throwable e) { - // pass } } @@ -910,6 +983,50 @@ private int validateIntMaxStrDigits(String input, String name) { throw abort(String.format("%s: invalid limit; must be >= %d or 0 for unlimited.", name, INT_MAX_STR_DIGITS_THRESHOLD), 1); } + private void applyJitModePreset(Map polyglotOptions, String xOption) { + boolean fallbackRuntime = usesFallbackRuntime(); + switch (xOption) { + case "jit=0": + if (!fallbackRuntime) { + polyglotOptions.put("engine.Compilation", "false"); + } + break; + case "jit=1": + if (!fallbackRuntime) { + applyLatencyJitPreset(polyglotOptions); + } + break; + case "jit=2": + if (!fallbackRuntime) { + applyThroughputJitPreset(polyglotOptions); + } + break; + default: + throw abort("Invalid argument for the -X jit option: expected jit=0, jit=1, or jit=2\n" + SHORT_HELP, 2); + } + } + + private boolean usesFallbackRuntime() { + return findOptionDescriptor("engine", "engine.Compilation") == null; + } + + private static void applyLatencyJitPreset(Map polyglotOptions) { + polyglotOptions.put("engine.CompilerThreads", "1"); + applyRaisedJitThresholds(polyglotOptions); + } + + private static void applyThroughputJitPreset(Map polyglotOptions) { + polyglotOptions.put("engine.Mode", "throughput"); + applyRaisedJitThresholds(polyglotOptions); + } + + private static void applyRaisedJitThresholds(Map polyglotOptions) { + polyglotOptions.put("engine.FirstTierCompilationThreshold", "10000"); + polyglotOptions.put("engine.LastTierCompilationThreshold", "100000"); + polyglotOptions.put("engine.OSRCompilationThreshold", "200704"); + polyglotOptions.put("engine.SingleTierCompilationThreshold", "100000"); + } + private static String toAbsolutePath(String executable) { if (executable.contains(":")) { // this is either already an absolute windows path, or not a single executable @@ -992,11 +1109,16 @@ private void findAndApplyVenvCfg(Builder contextBuilder, String executable) { } if (Files.exists(baseExecutable)) { contextBuilder.option("python.BaseExecutable", baseExecutable.toString()); - /* - * This is needed to support the legacy GraalVM layout where the - * executable is a symlink into the 'languages' directory. - */ - contextBuilder.option("python.PythonHome", baseExecutable.getParent().getParent().toString()); + if ("/app".equals(baseExecutable.toString())) { + // GraalOS case + contextBuilder.option("python.PythonHome", "/"); + } else { + /* + * This is needed to support the legacy GraalVM layout where the + * executable is a symlink into the 'languages' directory. + */ + contextBuilder.option("python.PythonHome", baseExecutable.getParent().getParent().toString()); + } } } catch (NullPointerException | InvalidPathException ex) { // NullPointerException covers the possible null result of getParent() @@ -1004,19 +1126,13 @@ private void findAndApplyVenvCfg(Builder contextBuilder, String executable) { } break; case "venvlauncher_command": - if (!hasContextOptionSetViaCommandLine("VenvlauncherCommand")) { - contextBuilder.option("python.VenvlauncherCommand", parts[1].trim()); - } + setOptionIfNotSetViaCommandLine(contextBuilder, "VenvlauncherCommand", parts[1].trim()); break; case "base-prefix": - if (!hasContextOptionSetViaCommandLine("SysBasePrefix")) { - contextBuilder.option("python.SysBasePrefix", parts[1].trim()); - } + setOptionIfNotSetViaCommandLine(contextBuilder, "SysBasePrefix", parts[1].trim()); break; case "base-executable": - if (!hasContextOptionSetViaCommandLine("BaseExecutable")) { - contextBuilder.option("python.BaseExecutable", parts[1].trim()); - } + setOptionIfNotSetViaCommandLine(contextBuilder, "BaseExecutable", parts[1].trim()); break; } } @@ -1047,6 +1163,12 @@ private String getContextOptionIfSetViaCommandLine(String key) { return null; } + private void setOptionIfNotSetViaCommandLine(Context.Builder builder, String key, String value) { + if (!hasContextOptionSetViaCommandLine(key)) { + builder.option("python." + key, value); + } + } + private boolean hasContextOptionSetViaCommandLine(String key) { if (System.getProperty("polyglot.python." + key) != null) { return System.getProperty("polyglot.python." + key) != null; @@ -1068,10 +1190,6 @@ private static void printFileNotFoundException(NoSuchFileException e) { } private void evalNonInteractive(Context context, ConsoleHandler consoleHandler) throws IOException { - // We need to setup the terminal even when not running the REPL because code may request - // input from the terminal. - setupTerminal(consoleHandler); - Source src; if (commandString != null) { src = Source.newBuilder(getLanguageId(), commandString, "").build(); @@ -1099,10 +1217,8 @@ protected void printHelp(OptionCategory maxCategory) { "-i : inspect interactively after running script; forces a prompt even\n" + " if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n" + "-m mod : run library module as a script (terminates option list)\n" + - "-O : on CPython, this optimizes generated bytecode slightly;\n" + - " GraalPython does not use bytecode, and thus this flag has no effect\n" + - "-OO : remove doc-strings in addition to the -O optimizations;\n" + - " GraalPython does not use bytecode, and thus this flag has no effect\n" + + "-O : remove assert statements from generated bytecode\n" + + "-OO : remove doc-strings in addition to the -O optimizations\n" + "-P : don't prepend a potentially unsafe path to sys.path; also PYTHONSAFEPATH" + "-R : on CPython, this enables the use of a pseudo-random salt to make\n" + " hash()values of various types be unpredictable between separate\n" + @@ -1117,7 +1233,9 @@ protected void printHelp(OptionCategory maxCategory) { " can be supplied multiple times to increase verbosity\n" + "-V : print the Python version number and exit (also --version)\n" + " when given twice, print more information about the build\n" + - "-X opt : CPython implementation-specific options. warn_default_encoding and int_max_str_digits are supported on GraalPy\n" + + "-X opt : set implementation-specific option\n" + + " CPython-compatible options supported by GraalPy: warn_default_encoding, int_max_str_digits\n" + + " GraalPy implementation-specific options: jit=0|1|2 (default: jit=1)\n" + "-W arg : warning control; arg is action:message:category:module:lineno\n" + " also PYTHONWARNINGS=arg\n" + "file : program read from script file\n" + @@ -1159,11 +1277,6 @@ protected void printHelp(OptionCategory maxCategory) { "\nEnvironment variables specific to the Graal Python launcher:\n" : "")); } - @Override - protected String[] getDefaultLanguages() { - return new String[]{getLanguageId(), "llvm", "regex"}; - } - @Override protected void collectArguments(Set options) { // This list of arguments is used when we are launched through the Polyglot @@ -1179,7 +1292,7 @@ private static ConsoleHandler createConsoleHandler(InputStream inStream, OutputS if (!isTTY()) { return new DefaultConsoleHandler(inStream); } else { - return new JLineConsoleHandler(inStream, outStream, false); + return new JLineConsoleHandler(inStream, outStream); } } @@ -1193,18 +1306,23 @@ private static ConsoleHandler createConsoleHandler(InputStream inStream, OutputS * In case 2, we must implicitly execute a {@code quit("default, 0L, TRUE} command before * exiting. So,in either case, we never return. */ - private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { - int lastStatus = 0; + private int readEvalPrint(Context context, ConsoleHandler consoleHandler, Value sysModule) { try { - setupREPL(context, consoleHandler); - Value sys = evalInternal(context, "import sys; sys"); - + Value hook = null; + try { + hook = sysModule.getMember("__interactivehook__"); + } catch (PolyglotException e) { + // ignore + } + if (hook != null) { + hook.execute(); + } while (true) { // processing inputs boolean doEcho = doEcho(context); - consoleHandler.setPrompt(doEcho ? sys.getMember("ps1").asString() : null); + String ps1 = doEcho ? sysModule.getMember("ps1").asString() : null; try { - String input = consoleHandler.readLine(); + String input = consoleHandler.readLine(ps1); if (input == null) { throw new EOFException(); } @@ -1213,26 +1331,25 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { continue; } - String continuePrompt = null; + String ps2 = null; StringBuilder sb = new StringBuilder(input).append('\n'); while (true) { // processing subsequent lines while input is incomplete - lastStatus = 0; try { context.eval(Source.newBuilder(getLanguageId(), sb.toString(), "").interactive(true).buildLiteral()); + flushInteractiveOutput(sysModule); } catch (PolyglotException e) { - if (continuePrompt == null) { - continuePrompt = doEcho ? sys.getMember("ps2").asString() : null; + if (ps2 == null) { + ps2 = doEcho ? sysModule.getMember("ps2").asString() : null; } if (e.isIncompleteSource()) { // read more input until we get an empty line - consoleHandler.setPrompt(continuePrompt); String additionalInput; boolean isIncompleteCode = false; // this for cases like empty lines // in tripplecode, where the // additional input can be empty, // but we should still continue do { - additionalInput = consoleHandler.readLine(); + additionalInput = consoleHandler.readLine(ps2); sb.append(additionalInput).append('\n'); try { // We try to parse every time, when an additional input is @@ -1265,6 +1382,7 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { continue; } } + flushInteractiveOutput(sysModule); // process the exception from eval or from the last parsing of the input // + additional source if (e.isExit()) { @@ -1277,10 +1395,6 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { * system may be broken */ System.err.println("An internal error occurred, continue at your own risk"); - lastStatus = 1; - } else { - // drop through to continue REPL and remember last eval was an error - lastStatus = 1; } } break; @@ -1292,7 +1406,7 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { } catch (PolyglotException e2) { if (e2.isExit()) { // don't use the exit code from the PolyglotException - return lastStatus; + return 0; } else if (e2.isCancelled()) { continue; } @@ -1300,7 +1414,7 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { } } System.out.println(); - return lastStatus; + return 0; } catch (UserInterruptException e) { // interrupted by ctrl-c } @@ -1310,6 +1424,22 @@ private int readEvalPrint(Context context, ConsoleHandler consoleHandler) { } } + private static void flushInteractiveOutput(Value sysModule) { + flushInteractiveStream(sysModule, "stderr"); + flushInteractiveStream(sysModule, "stdout"); + } + + private static void flushInteractiveStream(Value sysModule, String name) { + try { + Value stream = sysModule.getMember(name); + if (stream != null && !stream.isNull() && stream.canInvokeMember("flush")) { + stream.invokeMember("flush"); + } + } catch (PolyglotException | UnsupportedOperationException e) { + // Match CPython's interactive flush_io: stream flush failures are ignored. + } + } + private static boolean canSkipFromEval(String input) { String[] split = input.split("\n"); for (String s : split) { @@ -1324,52 +1454,6 @@ private Value evalInternal(Context context, String code) { return context.eval(Source.newBuilder(getLanguageId(), code, "").internal(true).buildLiteral()); } - private void setupREPL(Context context, ConsoleHandler consoleHandler) { - // Then we can get the readline module and see if any completers were registered and use its - // history feature - evalInternal(context, "import sys\ngetattr(sys, '__interactivehook__', lambda: None)()\n"); - final Value readline = evalInternal(context, "import readline; readline"); - final Value getCompleter = readline.getMember("get_completer").execute(); - final Value shouldRecord = readline.getMember("get_auto_history"); - final Value addHistory = readline.getMember("add_history"); - final Value getHistoryItem = readline.getMember("get_history_item"); - final Value setHistoryItem = readline.getMember("replace_history_item"); - final Value deleteHistoryItem = readline.getMember("remove_history_item"); - final Value clearHistory = readline.getMember("clear_history"); - final Value getHistorySize = readline.getMember("get_current_history_length"); - - Function> completer = null; - if (getCompleter.canExecute()) { - completer = (buffer) -> { - List candidates = new ArrayList<>(); - Value candidate = getCompleter.execute(buffer, candidates.size()); - while (candidate.isString()) { - candidates.add(candidate.asString()); - candidate = getCompleter.execute(buffer, candidates.size()); - } - return candidates; - }; - } - consoleHandler.setupReader( - () -> shouldRecord.execute().asBoolean(), - () -> getHistorySize.execute().asInt(), - (item) -> addHistory.execute(item), - (pos) -> getHistoryItem.execute(pos).asString(), - (pos, item) -> setHistoryItem.execute(pos, item), - (pos) -> deleteHistoryItem.execute(pos), - () -> clearHistory.execute(), - completer); - - } - - private static void setupTerminal(ConsoleHandler consoleHandler) { - consoleHandler.setupReader(() -> false, () -> 0, (item) -> { - }, (pos) -> null, (pos, item) -> { - }, (pos) -> { - }, () -> { - }, null); - } - /** * Some system properties have already been read at this point, so to change them, we just * re-execute the process with the additional options. diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java index 1ced83db92..16d25a78a4 100644 --- a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java +++ b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -43,94 +43,111 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.Reader; +import java.io.Writer; +import java.nio.charset.Charset; import java.nio.file.Path; import java.time.Instant; +import java.util.Collections; import java.util.LinkedList; -import java.util.List; import java.util.ListIterator; import java.util.NoSuchElementException; import java.util.function.BiConsumer; import java.util.function.BooleanSupplier; import java.util.function.Consumer; -import java.util.function.Function; import java.util.function.IntConsumer; import java.util.function.IntFunction; import java.util.function.IntSupplier; +import org.graalvm.polyglot.Value; import org.graalvm.shadowed.org.jline.keymap.KeyMap; import org.graalvm.shadowed.org.jline.reader.Binding; import org.graalvm.shadowed.org.jline.reader.Candidate; -import org.graalvm.shadowed.org.jline.reader.Completer; import org.graalvm.shadowed.org.jline.reader.EndOfFileException; import org.graalvm.shadowed.org.jline.reader.History; import org.graalvm.shadowed.org.jline.reader.LineReader; import org.graalvm.shadowed.org.jline.reader.LineReaderBuilder; import org.graalvm.shadowed.org.jline.reader.Macro; -import org.graalvm.shadowed.org.jline.reader.ParsedLine; import org.graalvm.shadowed.org.jline.reader.UserInterruptException; import org.graalvm.shadowed.org.jline.reader.impl.DefaultParser; import org.graalvm.shadowed.org.jline.terminal.Terminal; import org.graalvm.shadowed.org.jline.terminal.TerminalBuilder; +import org.graalvm.shadowed.org.jline.utils.InputStreamReader; -class JLineConsoleHandler extends ConsoleHandler { - private final boolean noPrompt; - private final Terminal terminal; +public class JLineConsoleHandler extends ConsoleHandler { + private final InputStream inputStream; + private final OutputStream outputStream; private LineReader reader; - private History history; - private String prompt; - private LinkedList lineBuffer = new LinkedList<>(); + private Reader fallbackReader; + private Writer fallbackWriter; + private final LinkedList lineBuffer = new LinkedList<>(); + private CompletionState completionState; + + JLineConsoleHandler(InputStream inputStream, OutputStream outputStream) { + this.inputStream = inputStream; + this.outputStream = outputStream; + } - JLineConsoleHandler(InputStream inStream, OutputStream outStream, boolean noPrompt) { - this.noPrompt = noPrompt; + // Called via interop from readline module initialization + @SuppressWarnings("unused") + public void initializeReadline(Value readlineModule) { + Terminal terminal; try { - this.terminal = TerminalBuilder.builder().jna(false).streams(inStream, outStream).system(true).signalHandler(Terminal.SignalHandler.SIG_IGN).build(); + terminal = TerminalBuilder.builder().jna(false).streams(inputStream, outputStream).system(true).signalHandler(Terminal.SignalHandler.SIG_IGN).build(); } catch (IOException ex) { throw new RuntimeException("unexpected error opening console reader", ex); } - } - - @Override - public void setupReader(BooleanSupplier shouldRecord, - IntSupplier getSize, - Consumer addItem, - IntFunction getItem, - BiConsumer setItem, - IntConsumer removeItem, - Runnable clear, - Function> completer) { - history = new HistoryImpl(shouldRecord, getSize, addItem, getItem, setItem, removeItem, clear); - - LineReaderBuilder builder = LineReaderBuilder.builder(); - builder = builder.terminal(terminal).history(history); - if (completer != null) { - builder.completer(new Completer() { - @Override - public void complete(LineReader r, ParsedLine pl, List candidates) { - String word = pl.word(); - if (word != null) { - List l = completer.apply(word); - for (String value : l) { - candidates.add(new Candidate(value, value, null, null, null, null, false)); + final Value getCompleter = readlineModule.getMember("get_completer"); + final Value shouldRecord = readlineModule.getMember("get_auto_history"); + final Value addHistory = readlineModule.getMember("add_history"); + final Value getHistoryItem = readlineModule.getMember("get_history_item"); + final Value setHistoryItem = readlineModule.getMember("replace_history_item"); + final Value deleteHistoryItem = readlineModule.getMember("remove_history_item"); + final Value clearHistory = readlineModule.getMember("clear_history"); + final Value getHistorySize = readlineModule.getMember("get_current_history_length"); + + LineReaderBuilder builder = LineReaderBuilder.builder().terminal(terminal); + builder.history(new HistoryImpl( + () -> shouldRecord.execute().asBoolean(), + () -> getHistorySize.execute().asInt(), + addHistory::execute, + (pos) -> getHistoryItem.execute(pos).asString(), + setHistoryItem::execute, + deleteHistoryItem::execute, + clearHistory::execute)); + builder.completer((r, pl, candidates) -> { + String word = pl.word(); + if (word != null) { + Value completer = getCompleter.execute(); + if (completer.canExecute()) { + try { + completionState = new CompletionState(); + completionState.line = pl.line(); + completionState.beginIdx = pl.cursor() - pl.word().length(); + completionState.endIdx = pl.cursor(); + int i = 0; + while (true) { + Value completerResult = completer.execute(word, i++); + if (completerResult.isString()) { + String completion = completerResult.asString(); + candidates.add(new Candidate(completion, completion, null, null, null, null, false)); + } else { + break; + } } + } finally { + completionState = null; } } - }); - } - - builder.parser(new DefaultParser() { - @Override - public boolean isDelimiterChar(CharSequence buffer, int pos) { - // Never count a last character of a char sequence as delimiter. The REPL completer - // implemented by `rlcompleter.py` adds a trailing whitespace to keywords, - // e.g. 'raise '. The default DefaultParser implementation always escaped this - // whitespace leading to wrong completions like 'raise\ '. - if (pos == buffer.length() - 1) { - return false; - } - return Character.isWhitespace(buffer.charAt(pos)); } }); + DefaultParser parser = new DefaultParser(); + // Disable escaping + parser.escapeChars(new char[0]); + builder.parser(parser); + reader = builder.build(); reader.option(LineReader.Option.DISABLE_EVENT_EXPANSION, true); reader.option(LineReader.Option.INSERT_TAB, true); @@ -156,14 +173,62 @@ public boolean isDelimiterChar(CharSequence buffer, int pos) { binding.bind(new Macro(KeyMap.translate("/")), KeyMap.translate("^[OQ")); } + public static class CompletionState { + public String line; + public int beginIdx; + public int endIdx; + } + + // Used via interop @Override - public String readLine(boolean showPrompt) { - if (lineBuffer.isEmpty()) { + public String readLine(String prompt) { + if (reader == null) { + if (fallbackReader == null) { + Charset charset; + try { + charset = Charset.forName(System.getProperty("stdin.encoding")); + } catch (Exception e) { + charset = Charset.defaultCharset(); + } + // Note: using InputStreamReader from jline.utils for truly unbuffered reads + fallbackReader = new InputStreamReader(inputStream, charset); + } try { - String lines = reader.readLine(showPrompt ? prompt : ""); - for (String line : lines.split("\n")) { - lineBuffer.add(line); + if (prompt != null && !prompt.isEmpty()) { + if (fallbackWriter == null) { + fallbackWriter = new OutputStreamWriter(outputStream); + } + fallbackWriter.write(prompt); + fallbackWriter.flush(); } + StringBuilder sb = new StringBuilder(); + while (true) { + int c = inputStream.read(); + if (c < 0) { + // EOF + if (!sb.isEmpty()) { + break; + } + if (prompt != null) { + fallbackWriter.write("\n"); + fallbackWriter.flush(); + } + return null; + } else if (c == '\n') { + break; + } else if (c != '\r') { + sb.append((char) c); + } + } + return sb.toString(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + if (lineBuffer.isEmpty()) { + try { + String lines = reader.readLine(prompt); + Collections.addAll(lineBuffer, lines.split("\n")); } catch (UserInterruptException e) { throw e; } catch (EndOfFileException e) { @@ -175,19 +240,10 @@ public String readLine(boolean showPrompt) { return lineBuffer.poll(); } - @Override - public void setPrompt(String prompt) { - this.prompt = noPrompt ? "" : prompt != null ? prompt : ""; - } - - @Override - public int getTerminalHeight() { - return terminal.getHeight(); - } - - @Override - public int getTerminalWidth() { - return terminal.getWidth(); + // Used via interop + @SuppressWarnings("unused") + public CompletionState getCompletionState() { + return completionState; } private static class HistoryImpl implements History { @@ -328,7 +384,7 @@ private void add(int idx, String val) { } @Override - public void purge() throws IOException { + public void purge() { clear.run(); } @@ -360,8 +416,7 @@ public History.Entry next() { if (!hasNext()) { throw new NoSuchElementException(); } - HistoryEntry e = new HistoryEntry(iterIndex++); - return e; + return new HistoryEntry(iterIndex++); } @Override @@ -380,8 +435,7 @@ public History.Entry previous() { if (!hasPrevious()) { throw new NoSuchElementException(); } - HistoryEntry e = new HistoryEntry(--iterIndex); - return e; + return new HistoryEntry(--iterIndex); } @Override @@ -437,27 +491,27 @@ public void attach(LineReader reader) { } @Override - public void load() throws IOException { + public void load() { } @Override - public void save() throws IOException { + public void save() { } @Override - public void write(Path path, boolean bln) throws IOException { + public void write(Path path, boolean bln) { } @Override - public void append(Path path, boolean bln) throws IOException { + public void append(Path path, boolean bln) { } @Override - public void read(Path path, boolean bln) throws IOException { + public void read(Path path, boolean bln) { } } diff --git a/graalpython/com.oracle.graal.python.tck/src/com/oracle/graal/python/tck/PythonProvider.java b/graalpython/com.oracle.graal.python.tck/src/com/oracle/graal/python/tck/PythonProvider.java index 0fdeb22170..ef2a495fd0 100644 --- a/graalpython/com.oracle.graal.python.tck/src/com/oracle/graal/python/tck/PythonProvider.java +++ b/graalpython/com.oracle.graal.python.tck/src/com/oracle/graal/python/tck/PythonProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -76,6 +76,7 @@ import org.graalvm.polyglot.Value; import org.graalvm.polyglot.tck.LanguageProvider; import org.graalvm.polyglot.tck.ResultVerifier; +import org.graalvm.polyglot.tck.ResultVerifier.SnippetRun; import org.graalvm.polyglot.tck.Snippet; import org.graalvm.polyglot.tck.TypeDescriptor; import org.junit.Assert; @@ -262,8 +263,8 @@ public Collection createExpressions(Context context) { addExpressionSnippet(context, snippets, "isinstance", "lambda x, y: isinstance(x, y)", BOOLEAN, ANY, META_OBJECT); addExpressionSnippet(context, snippets, "issubclass", "lambda x, y: issubclass(x, y)", BOOLEAN, META_OBJECT, META_OBJECT); - addExpressionSnippet(context, snippets, "[]", "lambda x, y: x[y]", ANY, GetItemVerifier.INSTANCE, union(array(ANY), STRING, hash(ANY, ANY)), ANY); - addExpressionSnippet(context, snippets, "[a:b]", "lambda x: x[:]", union(STRING, array(ANY)), union(STRING, array(ANY))); + addExpressionSnippet(context, snippets, "[]", "lambda x, y: x[y]", ANY, GetItemVerifier.INSTANCE, union(array(ANY), STRING, hash(ANY, ANY), META_OBJECT), ANY); + addExpressionSnippet(context, snippets, "[a:b]", "lambda x: x[:]", union(STRING, array(ANY)), SliceVerifier.INSTANCE, union(STRING, array(ANY), META_OBJECT)); // @formatter:on return snippets; @@ -493,6 +494,30 @@ public void accept(SnippetRun snippetRun) throws PolyglotException { private static final MulVerifier INSTANCE = new MulVerifier(); } + private static void checkTypeSubscripting(SnippetRun snippetRun, Value self) { + if (snippetRun.getException() != null) { + // only specific Python types allow parameterization + String metaName = self.getMetaQualifiedName(); + assert metaName.equals("object") || metaName.equals("type_user") : metaName; + } else { + assert snippetRun.getResult().getMetaObject().getMetaQualifiedName().equals("types.GenericAlias"); + } + } + + private static class SliceVerifier extends PResultVerifier { + @Override + public void accept(SnippetRun snippetRun) throws PolyglotException { + Value self = snippetRun.getParameters().get(0); + if (self.isMetaObject()) { + checkTypeSubscripting(snippetRun, self); + } else { + ResultVerifier.getDefaultResultVerifier().accept(snippetRun); + } + } + + private static final SliceVerifier INSTANCE = new SliceVerifier(); + } + private static class GetItemVerifier extends PResultVerifier { private static final String[] UNHASHABLE_TYPES = new String[]{"list", "dict", "bytearray", "set"}; @@ -542,6 +567,8 @@ public void accept(SnippetRun snippetRun) throws PolyglotException { } else { assert snippetRun.getException() == null : snippetRun.getException(); } + } else if (self.isMetaObject()) { + checkTypeSubscripting(snippetRun, self); } else { // argument type error, rethrow throw snippetRun.getException(); diff --git a/graalpython/com.oracle.graal.python.test.integration/pom.xml b/graalpython/com.oracle.graal.python.test.integration/pom.xml index 967285c13c..531b6a0028 100644 --- a/graalpython/com.oracle.graal.python.test.integration/pom.xml +++ b/graalpython/com.oracle.graal.python.test.integration/pom.xml @@ -64,7 +64,7 @@ Additionally, one can change the polyglot artifacts version with 17 17 UTF-8 - 26.0.0 + 25.1.0 diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/EngineOptionsTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/EngineOptionsTests.java index 1f9824edae..b547ff5300 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/EngineOptionsTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/EngineOptionsTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -41,6 +41,7 @@ package com.oracle.graal.python.test.integration; import static com.oracle.graal.python.test.integration.Utils.IS_WINDOWS; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; import static org.junit.Assert.assertEquals; import static org.junit.Assume.assumeFalse; @@ -57,7 +58,9 @@ public void engineOptions() { assertEquals("java", doit(engine, null)); assertEquals("java", doit(engine, "java")); - assertEquals("native", doit(engine, "native")); + // Native POSIX requires native access downcalls. When unavailable on JDK < 22 in JVM mode, + // requesting the native backend intentionally falls back to Java. + assertEquals(SUPPORTS_PANAMA ? "native" : "java", doit(engine, "native")); engine.close(); } diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/Utils.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/Utils.java index e47f5fa149..591dbc8015 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/Utils.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/Utils.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -47,6 +47,7 @@ public class Utils { public static final boolean IS_WINDOWS = System.getProperty("os.name").toLowerCase(Locale.ROOT).contains("windows"); + public static final boolean SUPPORTS_PANAMA = Runtime.version().feature() >= 22; public static String getThreadDump() { ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/AsyncActionThreadingTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/AsyncActionThreadingTest.java index 2329920f60..ca05802955 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/AsyncActionThreadingTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/AsyncActionThreadingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,10 +40,12 @@ */ package com.oracle.graal.python.test.integration.advanced; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import java.util.Arrays; +import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -76,8 +78,9 @@ Stream pythonThreads() { @Test public void testNoNewThreadsWithoutAutomaticAsyncActions() { Assume.assumeTrue("false".equalsIgnoreCase(System.getProperty("python.AutomaticAsyncActions"))); + Assume.assumeTrue("Requires JEP 454 support for _testcapi", SUPPORTS_PANAMA); long threadCount = pythonThreadCount(); - Context c = PythonTests.enterContext(); + Context c = PythonTests.enterContext(Map.of("python.AllowSignalHandlers", "true", "python.PosixModuleBackend", "native"), new String[0]); try { Runnable poll = c.getPolyglotBindings().getMember("PollPythonAsyncActions").asHostObject(); c.eval("python", "import re, itertools, functools, _testcapi"); diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/BenchmarkTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/BenchmarkTests.java index 642b709f2a..d1dbbb43fc 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/BenchmarkTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/BenchmarkTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2023, Oracle and/or its affiliates. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. * Copyright (c) 2014, Regents of the University of California * * All rights reserved. @@ -43,6 +43,12 @@ public void richards3() { assertBenchNoError(name, new String[]{name, "20"}); } + @Test + public void gr68715_collectOuterStackLocals() { + String name = "gr68715_collect_outer_stack_locals.py"; + assertBenchNoError(name, new String[]{name, "1000", "4", "4"}); + } + @Test public void bm_ai() { String name = "ai-nqueen.py"; diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/NativeExtTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/NativeExtTest.java index dcaf0dcb23..0fdf6e15aa 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/NativeExtTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/NativeExtTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,11 +40,17 @@ */ package com.oracle.graal.python.test.integration.advanced; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; import java.util.concurrent.CountDownLatch; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Engine; import org.graalvm.polyglot.PolyglotException; +import org.graalvm.polyglot.Value; import org.junit.Assert; import org.junit.Assume; import org.junit.BeforeClass; @@ -55,9 +61,12 @@ * because we cannot create multiple contexts that would load native extensions. */ public class NativeExtTest { + private static final String DELVEWHEEL_VERSION = "1.9.0"; + @BeforeClass public static void setUpClass() { Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("mac")); + Assume.assumeTrue(SUPPORTS_PANAMA); } @Test @@ -108,6 +117,52 @@ public void testSharingErrorWithCpythonSre() throws InterruptedException { } } + @Test + public void testMissingDelvewheelError() throws IOException { + Assume.assumeTrue(System.getProperty("os.name").toLowerCase().contains("win")); + + Path tempDir = Files.createTempDirectory("graalpy-no-delvewheel"); + try (Engine engine = Engine.create("python"); + Context context = newContext(engine).option("python.IsolateNativeModules", "true").option("python.Executable", tempDir.resolve("python.exe").toString()).environment("PATH", + tempDir.toString()).build()) { + try { + context.eval("python", "import _sqlite3"); + Assert.fail("importing _sqlite3 with python.IsolateNativeModules=true should fail when delvewheel is not on PATH"); + } catch (PolyglotException ex) { + Assert.assertTrue(ex.getMessage(), ex.isGuestException()); + Value exception = ex.getGuestObject(); + Assert.assertTrue(exception.isException()); + Assert.assertEquals(ex.getMessage(), "SystemError", exception.getMetaObject().getMetaSimpleName()); + Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("delvewheel==" + DELVEWHEEL_VERSION)); + } + } finally { + Files.deleteIfExists(tempDir); + } + } + + @Test + public void testMissingPatchelfError() throws IOException { + Assume.assumeTrue(System.getProperty("os.name").toLowerCase().contains("linux")); + + Path tempDir = Files.createTempDirectory("graalpy-no-patchelf"); + try (Engine engine = Engine.create("python"); + Context context = newContext(engine).option("python.IsolateNativeModules", "true").option("python.Executable", tempDir.resolve("python").toString()).environment("PATH", + tempDir.toString()).build()) { + try { + context.eval("python", "import _sqlite3"); + Assert.fail("importing _sqlite3 with python.IsolateNativeModules=true should fail when patchelf is not on PATH"); + } catch (PolyglotException ex) { + Assert.assertTrue(ex.getMessage(), ex.isGuestException()); + Value exception = ex.getGuestObject(); + Assert.assertTrue(exception.isException()); + Assert.assertEquals(ex.getMessage(), "SystemError", exception.getMetaObject().getMetaSimpleName()); + Assert.assertTrue(ex.getMessage(), ex.getMessage().contains("patchelf`")); + } + } finally { + Files.deleteIfExists(tempDir); + } + } + private static Context.Builder newContext(Engine engine) { return Context.newBuilder().allowExperimentalOptions(true).allowAllAccess(true).engine(engine); } diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ResourcesTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ResourcesTest.java index c2ba25acac..241f674cc5 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ResourcesTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ResourcesTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -43,6 +43,9 @@ import static org.junit.Assert.assertTrue; import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Engine; @@ -79,4 +82,33 @@ public void testResourcesAlwaysAllowReading() { assertTrue(foundHome, foundHome.contains("python" + File.separator + "python-home")); } } + + @Test + public void testTracebackSourceLineRespectsDeniedIO() throws IOException { + Path sourceFile = Files.createTempFile("graalpy-traceback-source", ".py"); + String leakedLine = "this line must not appear in the traceback"; + Files.writeString(sourceFile, leakedLine + "\n"); + try (Context context = Context.newBuilder("python").allowIO(IOAccess.NONE).build()) { + String traceback = context.eval("python", """ + import io + import traceback + + code = compile("1/0\\n", '%s', "exec") + out = io.StringIO() + try: + exec(code) + except ZeroDivisionError: + traceback.print_exc(file=out) + out.getvalue() + """.formatted(escapePythonString(sourceFile.toString()))).asString(); + assertTrue(traceback, traceback.contains(sourceFile.toString())); + assertTrue(traceback, !traceback.contains(leakedLine)); + } finally { + Files.deleteIfExists(sourceFile); + } + } + + private static String escapePythonString(String value) { + return value.replace("\\", "\\\\").replace("'", "\\'"); + } } diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPathTraversalTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPathTraversalTest.java new file mode 100644 index 0000000000..71e938e108 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPathTraversalTest.java @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.integration.advanced; + +import static com.oracle.graal.python.test.integration.Utils.IS_WINDOWS; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeFalse; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.io.IOAccess; +import org.junit.Test; + +public class SandboxPathTraversalTest { + private static final String MARKER = "sandbox-path-traversal-marker"; + private static final String LEAKED_PREFIX = "LEAKED:"; + private static final String POSIX_BACKEND = "java"; + + @Test + public void cannotListHostDirectoryViaLanguageHomeDotDotPath() throws IOException { + assumeFalse(IS_WINDOWS); + Path directory = Files.createTempDirectory("graalpy-sandbox-list"); + Path markerFile = Files.writeString(directory.resolve("marker.txt"), MARKER, StandardCharsets.UTF_8); + try { + String source = listDirectoryScript(pythonStringLiteral(directory.toRealPath().toString())); + String unrestrictedResult = eval(source, IOAccess.ALL); + assertTrue(unrestrictedResult, unrestrictedResult.contains(markerFile.getFileName().toString())); + + String result = eval(source, IOAccess.NONE); + assertFalse(result, result.startsWith(LEAKED_PREFIX)); + } finally { + Files.deleteIfExists(markerFile); + Files.deleteIfExists(directory); + } + } + + @Test + public void cannotReadHostPyFileViaLanguageHomeDotDotPath() throws IOException { + assumeFalse(IS_WINDOWS); + Path directory = Files.createTempDirectory("graalpy-sandbox-read"); + Path secretFile = Files.writeString(directory.resolve("secret.py"), MARKER, StandardCharsets.UTF_8); + try { + String source = readFileScript(pythonStringLiteral(secretFile.toRealPath().toString())); + assertEquals(LEAKED_PREFIX + MARKER, eval(source, IOAccess.ALL)); + + String result = eval(source, IOAccess.NONE); + assertFalse(result, result.startsWith(LEAKED_PREFIX)); + } finally { + Files.deleteIfExists(secretFile); + Files.deleteIfExists(directory); + } + } + + @Test + public void cannotReadHostFileViaTracebackSourceLineRendering() throws IOException { + assumeFalse(IS_WINDOWS); + Path directory = Files.createTempDirectory("graalpy-sandbox-traceback"); + String contents = MARKER + "\n" + MARKER + "-second\n"; + Path secretFile = Files.writeString(directory.resolve("secret"), contents, StandardCharsets.UTF_8); + try { + String source = tracebackSourceLineScript(pythonStringLiteral(secretFile.toRealPath().toString())); + assertEquals(LEAKED_PREFIX + MARKER + "\n" + MARKER + "-second", eval(source, IOAccess.ALL)); + + String result = eval(source, IOAccess.NONE); + assertFalse(result, result.startsWith(LEAKED_PREFIX)); + assertFalse(result, result.contains(MARKER)); + } finally { + Files.deleteIfExists(secretFile); + Files.deleteIfExists(directory); + } + } + + private static String eval(String source, IOAccess ioAccess) { + try (Context context = Context.newBuilder("python").allowIO(ioAccess).option("python.PosixModuleBackend", POSIX_BACKEND).build()) { + assertEquals(POSIX_BACKEND, context.eval("python", "__graalpython__.posix_module_backend()").asString()); + return context.eval("python", source).asString(); + } + } + + private static String listDirectoryScript(String directory) { + return """ + %s + import os + + # Build a host directory path prefixed with the language home and followed + # by enough '..' components to escape it again lexically. + escaped = escaped_path(%s) + try: + # A successful result would mean os.listdir reached the host directory + # through getPublicTruffleFileRelaxed despite restricted IO. + result = "LEAKED:" + ",".join(sorted(os.listdir(escaped))) + except BaseException as e: + result = "BLOCKED:" + type(e).__name__ + result + """.formatted(escapedPathFunction(), directory); + } + + private static String readFileScript(String file) { + return """ + %s + # The target file is deliberately named secret.py to exercise the relaxed + # guard's allowed-suffix branch. + escaped = escaped_path(%s) + try: + # A successful result would mean open() reached the host file through + # the internal TruffleFile returned by getPublicTruffleFileRelaxed. + with open(escaped, "r", encoding="utf-8") as f: + result = "LEAKED:" + f.read() + except BaseException as e: + result = "BLOCKED:" + type(e).__name__ + result + """.formatted(escapedPathFunction(), file); + } + + private static String tracebackSourceLineScript(String file) { + return """ + import io + import traceback + + def read_file(host_path, max_lines=100): + # Ask traceback rendering for source lines associated with a compiled + # code object's host filename. The filename is the raw host path, not a + # language-home-prefixed traversal path. + out = [] + for n in range(1, max_lines + 1): + src = "\\n" * (n - 1) + "1/0\\n" + buf = io.StringIO() + try: + exec(compile(src, host_path, "exec")) + except ZeroDivisionError: + traceback.print_exc(file=buf) + line = None + for ln in buf.getvalue().splitlines(): + s = ln.strip() + if s and not s.startswith(("Traceback", "File ", "ZeroDivisionError", "~", "1/0")): + line = s + break + if line is None: + break + out.append(line) + return out + + try: + lines = read_file(%s) + result = "LEAKED:" + "\\n".join(lines) if lines else "BLOCKED:no-source-line" + except BaseException as e: + result = "BLOCKED:" + type(e).__name__ + result + """.formatted(file); + } + + private static String escapedPathFunction() { + return """ + def escaped_path(target): + import os + # __graalpython__.home is PythonContext.langHome, which is what + # isPyFileInLanguageHome compares against. + home = __graalpython__.home + # Count non-empty path elements so the generated path climbs from the + # absolute language home back to the filesystem root. The raw path still + # starts with home, but its normalized form is the supplied host target. + parts = [p for p in home.split(os.sep) if p] + return home + (os.sep + "..") * len(parts) + target + """; + } + + private static String pythonStringLiteral(String value) { + return "'" + value.replace("\\", "\\\\").replace("'", "\\'") + "'"; + } +} diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPolicyUntrustedTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPolicyUntrustedTest.java index 303216b560..087e4fb726 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPolicyUntrustedTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/SandboxPolicyUntrustedTest.java @@ -43,14 +43,23 @@ import static org.junit.Assert.assertEquals; import java.io.ByteArrayOutputStream; +import java.nio.charset.Charset; +import java.util.function.Consumer; +import java.util.function.Function; import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.PolyglotException; import org.graalvm.polyglot.SandboxPolicy; import org.graalvm.polyglot.Value; import org.junit.Assume; import org.junit.BeforeClass; import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; +@RunWith(Parameterized.class) public class SandboxPolicyUntrustedTest { @BeforeClass public static void setupClass() { @@ -58,43 +67,77 @@ public static void setupClass() { Assume.assumeTrue(requestedTest != null && requestedTest.equals(SandboxPolicyUntrustedTest.class.getSimpleName())); } - private static Value run(String source) { + public record ContextConfig(String name, Consumer config) { + @Override + public String toString() { + return name(); + } + } + + @Parameters(name = "{0}") + public static ContextConfig[] configs() { + return new ContextConfig[]{ + new ContextConfig("UNTRUSTED", b -> b // + .sandbox(SandboxPolicy.ISOLATED) // + .option("engine.MaxIsolateMemory", "1GB")), + new ContextConfig("ISOLATED", b -> b // + .sandbox(SandboxPolicy.ISOLATED) // + .option("engine.MaxIsolateMemory", "1GB")), + new ContextConfig("CONSTRAINED", b -> b // + .sandbox(SandboxPolicy.CONSTRAINED)), + }; + } + + @Parameter public ContextConfig config; + + private R run(String source, Function resultFun) { + // encodings import during ctx init takes 19 frames + return run(source, 20, resultFun); + } + + private R run(String source, int maxStackFrames, Function resultFun) { ByteArrayOutputStream output = new ByteArrayOutputStream(); ByteArrayOutputStream errorOutput = new ByteArrayOutputStream(); try (Context context = Context.newBuilder("python") // - .sandbox(SandboxPolicy.UNTRUSTED) // .out(output) // .err(errorOutput) // - .option("engine.MaxIsolateMemory", "1GB") // - .option("sandbox.MaxHeapMemory", "800MB") // + .apply(config.config()).option("sandbox.MaxHeapMemory", "800MB") // .option("sandbox.MaxCPUTime", "10s") // .option("sandbox.MaxASTDepth", "100") // - .option("sandbox.MaxStackFrames", "10") // + .option("sandbox.MaxStackFrames", Integer.toString(maxStackFrames)) // .option("sandbox.MaxThreads", "1") // .option("sandbox.MaxOutputStreamSize", "1MB") // .option("sandbox.MaxErrorStreamSize", "1MB") // .build()) { - return context.eval("python", source); + return resultFun.apply(context.eval("python", source)); + } catch (PolyglotException e) { + System.out.println("stdout:"); + System.out.println(output.toString(Charset.defaultCharset())); + System.out.println("--------"); + System.out.println("stderr:"); + System.out.println(errorOutput.toString(Charset.defaultCharset())); + throw e; } } @Test public void helloworld() { - assertEquals("hello world", run("'hello world'").asString()); + assertEquals("hello world", run("'hello world'", Value::asString)); } @Test public void canImportBuiltinModules() { - assertEquals("graalpy", run("import sys; sys.implementation.name").asString()); + assertEquals("graalpy", run("import sys; sys.implementation.name", Value::asString)); } @Test public void canImportNonBuiltinModules() { - assertEquals("email", run("import email; email.__name__").asString()); + assertEquals("email", run("import email; email.__name__", Value::asString)); } @Test public void doesNotLeakEnvironmentVariables() { - assertEquals("", run("import os; os.environ.get('JAVA_HOME', '')").asString()); + int maxStackFrames = 27; + assertEquals("", run("import os; os.environ.get('JAVA_HOME', '')", maxStackFrames, Value::asString)); } } diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ShutdownTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ShutdownTest.java index 05a7caca42..895ca8f050 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ShutdownTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/advanced/ShutdownTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,6 +40,8 @@ */ package com.oracle.graal.python.test.integration.advanced; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; @@ -59,6 +61,7 @@ public class ShutdownTest extends PythonTests { @BeforeClass public static void setUpClass() { Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("mac")); + Assume.assumeTrue(SUPPORTS_PANAMA); } @Test diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/basic/HelloWorldTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/basic/HelloWorldTests.java index 2760fa1d79..4843b483cb 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/basic/HelloWorldTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/basic/HelloWorldTests.java @@ -32,6 +32,8 @@ import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Engine; +import org.graalvm.polyglot.Value; +import org.junit.Assert; import org.junit.Test; import com.oracle.graal.python.test.integration.PythonTests; @@ -50,6 +52,12 @@ public void helloworldAgain() { PythonTests.assertPrints("hello\n", source); } + @Test + public void helloworldExpression() { + Value value = PythonTests.eval("'hello world'"); + Assert.assertEquals("hello world", value.asString()); + } + @Test public void usesFrozenModules() { final ByteArrayOutputStream byteArray = new ByteArrayOutputStream(); diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/builtin/HashingTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/builtin/HashingTest.java index 17dc9bdc5a..749b357add 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/builtin/HashingTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/builtin/HashingTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -197,8 +197,9 @@ public void dictEqualTest3() { @Test public void setAndTest() { - assertPrints("{2}\n", "print({2, 3} ^ {3})\n"); - assertPrints("{'c', 'b'}\n", "print({'a', 'c'} ^ frozenset({'a', 'b'}))\n"); - assertPrints("frozenset({'b'})\n", "print(frozenset({'a', 'c'}) ^ {'a', 'b', 'c'})\n"); + String source = "assert {2, 3} ^ {3} == {2}\n" + + "assert {'a', 'c'} ^ frozenset({'a', 'b'}) == {'b', 'c'}\n" + + "assert frozenset({'a', 'c'}) ^ {'a', 'b', 'c'} == frozenset({'b'})\n"; + assertPrints("", source); } } diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/engine/SharedEngineMultithreadingBenchmarkTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/engine/SharedEngineMultithreadingBenchmarkTest.java index dd950b7189..b56fc879a9 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/engine/SharedEngineMultithreadingBenchmarkTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/engine/SharedEngineMultithreadingBenchmarkTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -54,7 +54,7 @@ public class SharedEngineMultithreadingBenchmarkTest extends SharedEngineMultithreadingTestBase { @BeforeClass public static void setUpClass() { - Assume.assumeFalse(isMacOS() || isAArch64()); + Assume.assumeFalse(isMacOS()); } @Test diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/grammar/AsyncTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/grammar/AsyncTests.java index 6653b44e2c..1d6a2e7934 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/grammar/AsyncTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/grammar/AsyncTests.java @@ -50,7 +50,6 @@ public class AsyncTests { @Test public void nativeCoroutine() { assumeFalse(IS_WINDOWS); - assumeFalse("TODO: not implemented PGenerator.getYieldFrom(PGenerator.java:204)", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); String source = "import asyncio\n" + "async def foo():\n" + " return 42\n" + @@ -63,7 +62,6 @@ public void nativeCoroutine() { @Test public void asyncWith() { assumeFalse(IS_WINDOWS); - assumeFalse("TODO: not implemented PGenerator.getYieldFrom(PGenerator.java:204)", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); String source = "import asyncio\n" + "class AsyncContextManager:\n" + " async def __aenter__(self):\n" + @@ -89,7 +87,6 @@ public void asyncWith() { @Test public void asyncWithExceptional() { assumeFalse(IS_WINDOWS); - assumeFalse("TODO: not implemented PGenerator.getYieldFrom(PGenerator.java:204)", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); String source = "import asyncio\n" + "class AsyncContextManager:\n" + " async def __aenter__(self):\n" + diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/interop/JavaInteropTest.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/interop/JavaInteropTest.java index 2e120a0f37..a78d825b0f 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/interop/JavaInteropTest.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/interop/JavaInteropTest.java @@ -48,7 +48,6 @@ import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java.nio.charset.StandardCharsets; import java.util.ArrayList; @@ -56,6 +55,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Context.Builder; @@ -107,6 +107,14 @@ public void tearDown() { context.getEngine().close(); } + private String getOutString() { + return out.toString(StandardCharsets.UTF_8).replaceAll("\r\n", "\n"); + } + + private String getErrString() { + return err.toString(StandardCharsets.UTF_8).replaceAll("\r\n", "\n"); + } + @Test public void evalFailsOnError() { boolean didFail = false; @@ -212,17 +220,33 @@ public void testHostException() { context.eval(createSource("import java; java.math.BigInteger.ONE.divide(java.math.BigInteger.ZERO)")); fail(); } catch (PolyglotException e) { - Assert.assertTrue(e.isHostException()); - Assert.assertTrue(e.asHostException() instanceof ArithmeticException); - Assert.assertTrue(e.getMessage(), e.getMessage().contains("divide by zero")); + try { + Assert.assertTrue(e.isHostException()); + Assert.assertTrue(e.asHostException() instanceof ArithmeticException); + Assert.assertTrue(e.getMessage(), e.getMessage().contains("divide by zero")); + } catch (AssertionError assertionError) { + throw new AssertionError(getAssertionMessage(e), assertionError); + } } - String outString = out.toString(StandardCharsets.UTF_8); - String errString = err.toString(StandardCharsets.UTF_8); + String outString = getOutString(); + String errString = getErrString(); Assert.assertTrue(outString, outString.isEmpty()); Assert.assertTrue(errString, errString.isEmpty()); } + private static String getAssertionMessage(PolyglotException ex) { + var builder = new StringBuilder(ex.getClass().getSimpleName() + "\n"); + try { + builder.append(ex.getMessage()); + builder.append('\n'); + builder.append(Arrays.stream(ex.getStackTrace()).map(StackTraceElement::toString).collect(Collectors.joining("\n"))); + } catch (Throwable ignore) { + // pass + } + return builder.toString(); + } + @Test public void javaArraySet() { String source = "import java\n" + @@ -257,7 +281,7 @@ def is_none(x): } @Test - public void testPassingFloats() throws UnsupportedEncodingException { + public void testPassingFloats() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo(x, y):\n" + @@ -266,11 +290,11 @@ public void testPassingFloats() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute((float) 1.0, (float) 2.0); - assertEquals("2.0\n", out.toString("UTF-8")); + assertEquals("2.0\n", getOutString()); } @Test - public void testPassingBigIntegers() throws UnsupportedEncodingException { + public void testPassingBigIntegers() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo(x, y):\n" + @@ -279,20 +303,20 @@ public void testPassingBigIntegers() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute(BigInteger.valueOf(Long.MAX_VALUE).multiply(BigInteger.TWO), BigInteger.valueOf(7)); - assertEquals("129127208515966861298\n", out.toString("UTF-8")); + assertEquals("129127208515966861298\n", getOutString()); out.reset(); main.execute(Long.MAX_VALUE, 14); - assertEquals("129127208515966861298\n", out.toString("UTF-8")); + assertEquals("129127208515966861298\n", getOutString()); out.reset(); main.execute(6, 7); - assertEquals("42\n", out.toString("UTF-8")); + assertEquals("42\n", getOutString()); out.reset(); main.execute(true, true); - assertEquals("1\n", out.toString("UTF-8")); + assertEquals("1\n", getOutString()); } @Test - public void testBigIntegersAdd() throws UnsupportedEncodingException { + public void testBigIntegersAdd() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo(x, y):\n" + @@ -301,20 +325,20 @@ public void testBigIntegersAdd() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute(BigInteger.valueOf(24).shiftLeft(101), BigInteger.valueOf(7)); - assertEquals("60847228810955011271841753858055\n", out.toString("UTF-8")); + assertEquals("60847228810955011271841753858055\n", getOutString()); out.reset(); main.execute(BigInteger.valueOf(24).shiftLeft(101), BigInteger.valueOf(24).shiftLeft(101)); - assertEquals("121694457621910022543683507716096\n", out.toString("UTF-8")); + assertEquals("121694457621910022543683507716096\n", getOutString()); out.reset(); main.execute(6, 7); - assertEquals("13\n", out.toString("UTF-8")); + assertEquals("13\n", getOutString()); out.reset(); main.execute(true, true); - assertEquals("2\n", out.toString("UTF-8")); + assertEquals("2\n", getOutString()); } @Test - public void testBigIntegersEg() throws UnsupportedEncodingException { + public void testBigIntegersEg() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo(x, y):\n" + @@ -323,26 +347,26 @@ public void testBigIntegersEg() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute(BigInteger.valueOf(24).shiftLeft(101), BigInteger.valueOf(7)); - assertEquals("False\n", out.toString("UTF-8")); + assertEquals("False\n", getOutString()); out.reset(); main.execute(BigInteger.valueOf(24).shiftLeft(101), BigInteger.valueOf(24).shiftLeft(101)); - assertEquals("True\n", out.toString("UTF-8")); + assertEquals("True\n", getOutString()); out.reset(); main.execute(6, 7); - assertEquals("False\n", out.toString("UTF-8")); + assertEquals("False\n", getOutString()); out.reset(); main.execute(6, 6); - assertEquals("True\n", out.toString("UTF-8")); + assertEquals("True\n", getOutString()); out.reset(); main.execute(true, BigInteger.ONE); - assertEquals("True\n", out.toString("UTF-8")); + assertEquals("True\n", getOutString()); out.reset(); main.execute(true, BigInteger.ZERO); - assertEquals("False\n", out.toString("UTF-8")); + assertEquals("False\n", getOutString()); } @Test - public void testAsFunction() throws UnsupportedEncodingException { + public void testAsFunction() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo():\n" + @@ -351,11 +375,11 @@ public void testAsFunction() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute(); - assertEquals("Called\n", out.toString("UTF-8")); + assertEquals("Called\n", getOutString()); } @Test - public void testAsFunctionVarArgs() throws UnsupportedEncodingException { + public void testAsFunctionVarArgs() { String source = "import polyglot\n" + "@polyglot.export_value\n" + "def foo(a, b):\n" + @@ -364,28 +388,28 @@ public void testAsFunctionVarArgs() throws UnsupportedEncodingException { context.eval(script); Value main = context.getPolyglotBindings().getMember("foo"); main.execute("Hello", "World"); - assertEquals("Hello World\n", out.toString("UTF-8")); + assertEquals("Hello World\n", getOutString()); } @Test - public void mainFunctionsAreImplicitlyImporteable() throws UnsupportedEncodingException { + public void mainFunctionsAreImplicitlyImporteable() { String source = "def foo(a, b):\n" + " print(a, b)\n\n"; Source script = Source.create("python", source); context.eval(script); Value main = context.getBindings("python").getMember("foo"); main.execute("Hello", "World"); - assertEquals("Hello World\n", out.toString("UTF-8")); + assertEquals("Hello World\n", getOutString()); } @Test - public void builtinFunctionsAreImporteable() throws UnsupportedEncodingException { + public void builtinFunctionsAreImporteable() { String source = "pass"; Source script = Source.create("python", source); context.eval(script); Value main = context.getBindings("python").getMember("__builtins__").getMember("print"); main.execute("Hello", "World"); - assertEquals("Hello World\n", out.toString("UTF-8")); + assertEquals("Hello World\n", getOutString()); } @Test @@ -394,14 +418,14 @@ public void enumeratingMainBindingsWorks() throws Exception { } @Test - public void testMultipleInvocationsAreInSameScope() throws UnsupportedEncodingException { + public void testMultipleInvocationsAreInSameScope() { String source = "def foo(a, b):\n" + " print(a, b)\n" + "foo"; Source script = Source.create("python", source); Value foo = context.eval(script); foo.execute("Hello", "World"); - assertEquals("Hello World\n", out.toString("UTF-8")); + assertEquals("Hello World\n", getOutString()); source = "def bar(a, b):\n" + " foo(a, b)\n" + @@ -409,7 +433,7 @@ public void testMultipleInvocationsAreInSameScope() throws UnsupportedEncodingEx script = Source.create("python", source); Value bar = context.eval(script); bar.execute("Hello", "World"); - assertEquals("Hello World\nHello World\n", out.toString("UTF-8")); + assertEquals("Hello World\nHello World\n", getOutString()); source = "invalid syntax"; script = Source.create("python", source); @@ -418,9 +442,9 @@ public void testMultipleInvocationsAreInSameScope() throws UnsupportedEncodingEx } catch (Throwable t) { } bar.execute("Hello", "World"); - assertEquals("Hello World\nHello World\nHello World\n", out.toString("UTF-8")); + assertEquals("Hello World\nHello World\nHello World\n", getOutString()); foo.execute("Hello", "World"); - assertEquals("Hello World\nHello World\nHello World\nHello World\n", out.toString("UTF-8")); + assertEquals("Hello World\nHello World\nHello World\nHello World\n", getOutString()); } @Test @@ -568,7 +592,7 @@ public void accessJavaObjectFields() throws IOException { "5.0 \n" + "6.0 \n" + "True \n" + - "c \n", out.toString("UTF-8")); + "c \n", getOutString()); } @Test @@ -595,7 +619,7 @@ public void accessJavaObjectGetters() throws IOException { "5.0 \n" + "6.0 \n" + "True \n" + - "c \n", out.toString("UTF-8")); + "c \n", getOutString()); } @Test @@ -612,7 +636,7 @@ public void javaStringsAndPythonStrings() throws IOException { assertEquals("" + "\n" + "True\n" + - "True\n", out.toString("UTF-8")); + "True\n", getOutString()); } @Test diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/module/LzmaTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/module/LzmaTests.java index 0cb48b5c6e..fc28d5e072 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/module/LzmaTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/module/LzmaTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/runtime/ProfileTests.java b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/runtime/ProfileTests.java index 279ca064df..255ad09151 100644 --- a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/runtime/ProfileTests.java +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/runtime/ProfileTests.java @@ -40,9 +40,12 @@ */ package com.oracle.graal.python.test.integration.runtime; +import static com.oracle.graal.python.test.integration.PythonTests.eval; + import java.io.ByteArrayOutputStream; import java.io.PrintStream; +import org.graalvm.polyglot.Value; import org.junit.Assert; import org.junit.Assume; import org.junit.Test; @@ -68,7 +71,9 @@ public void profileYield() { @Test public void profileException() { - Assume.assumeFalse("TODO: wrong stacktrace", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); + Value isBytecodeDLS = eval("__graalpython__.is_bytecode_dsl_interpreter"); + // GR-71916 + Assume.assumeFalse("TODO: wrong stacktrace", isBytecodeDLS.asBoolean()); String source = "import sys\n" + "def f(frame, event, arg): print(frame, event, arg)\n" + "sys.setprofile(f)\n" + diff --git a/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/scripts/gr68715_collect_outer_stack_locals.py b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/scripts/gr68715_collect_outer_stack_locals.py new file mode 100644 index 0000000000..19cb9836c6 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/scripts/gr68715_collect_outer_stack_locals.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# The Universal Permissive License (UPL), Version 1.0 +# +# Subject to the condition set forth below, permission is hereby granted to any +# person obtaining a copy of this software, associated documentation and/or +# data (collectively the "Software"), free of charge and under any and all +# copyright rights in the Software, and any and all patent rights owned or +# freely licensable by each licensor hereunder covering either (i) the +# unmodified Software as contributed to or provided by such licensor, or (ii) +# the Larger Works (as defined below), to deal in both +# +# (a) the Software, and +# +# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if +# one is included with the Software each a "Larger Work" to which the Software +# is contributed by such licensors), +# +# without restriction, including without limitation the rights to copy, create +# derivative works of, display, perform, and distribute the Software and make, +# use, sell, offer for sale, import, export, have made, and have sold the +# Software and the Larger Work(s), and to sublicense the foregoing rights on +# either these or other terms. +# +# This license is subject to the following condition: +# +# The above copyright notice and either this complete permission notice or at a +# minimum a reference to the UPL must be included in all copies or substantial +# portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import inspect +import sys +import types +from functools import wraps + + +def make_fast_depends_utils_module(): + # Model the frame-walking dependency-injection helper shape found in the wild. + module = types.ModuleType("autogen.fast_depends.utils") + filename = "autogen/fast_depends/utils.py" + module.__file__ = filename + code = r''' +import inspect + + +def collect_outer_stack_locals(): + frame = inspect.currentframe() + current_filename = __file__ + locals_ = {} + while frame: + frame_filename = frame.f_code.co_filename + if frame_filename != current_filename: + locals_.update(frame.f_locals) + frame = frame.f_back + return locals_ +''' + exec(compile(code, filename, "exec"), module.__dict__) + return module + + +fast_depends_utils = make_fast_depends_utils_module() +collect_outer_stack_locals = fast_depends_utils.collect_outer_stack_locals + + +class Depends: + def __init__(self, dependency): + self.dependency = dependency + + +def get_typed_signature(call): + outer_locals = collect_outer_stack_locals() + signature = inspect.signature(call) + resolved = [] + for name, parameter in signature.parameters.items(): + annotation = parameter.annotation + if isinstance(annotation, str): + try: + annotation = eval(annotation, call.__globals__, outer_locals) + except NameError: + annotation = object + resolved.append((name, annotation, parameter.default)) + return resolved + + +def build_call_model(call, depth): + typed_signature = get_typed_signature(call) + if depth <= 0: + return typed_signature + for _, _, default in typed_signature: + if isinstance(default, Depends): + build_call_model(default.dependency, depth - 1) + return typed_signature + + +def inject(call=None, *, depth=3): + def decorate(func): + @wraps(func) + def func_wrapper(*args, **kwargs): + build_call_model(func, depth) + return func(*args, **kwargs) + + return func_wrapper + + if call is None: + return decorate + return decorate(call) + + +def make_dependency_chain(index, depth): + class LocalPayload: + __slots__ = ("value",) + + def __init__(self, value): + self.value = value + + def leaf(item: "LocalPayload" = None): + return item.value if item else index + + dependency = leaf + for layer in range(depth): + previous = dependency + + def dependency(item: "LocalPayload" = None, dep=Depends(previous), layer=layer): + if item is None: + item = LocalPayload(index + layer) + return dep.dependency(item) + + return dependency + + +def generator_adapter(value): + yield value + yield value + 1 + + +def make_tool(index, depth): + dependency = make_dependency_chain(index, depth) + + @inject(depth=depth) + def tool(payload: "LocalPayload" = None, dep=Depends(dependency)): + return sum(value for value in generator_adapter(dep.dependency(payload))) + + class LocalPayload: + __slots__ = ("value",) + + def __init__(self, value): + self.value = value + + return tool + + +def register_for_execution(functions): + registry = {} + + def decorator(func): + build_call_model(func, 2) + registry[func.__name__] = func + functions.append(func) + return func + + return decorator, registry + + +def create_agent(function_count, depth): + functions = [] + decorator, registry = register_for_execution(functions) + for index in range(function_count): + decorator(make_tool(index, depth)) + return registry, functions + + +def invoke_workflow(functions, iterations): + total = 0 + for _ in range(iterations): + for func in functions: + total += func() + return total + + +def main(): + iterations = int(sys.argv[1]) if len(sys.argv) > 1 else 1000 + function_count = int(sys.argv[2]) if len(sys.argv) > 2 else 4 + depth = int(sys.argv[3]) if len(sys.argv) > 3 else 4 + _, functions = create_agent(function_count, depth) + print("done result=%d" % invoke_workflow(functions, iterations)) + + +if __name__ == "__main__": + main() diff --git a/graalpython/com.oracle.graal.python.test/AGENTS.md b/graalpython/com.oracle.graal.python.test/AGENTS.md new file mode 100644 index 0000000000..2969e8ca18 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/AGENTS.md @@ -0,0 +1,19 @@ +# com.oracle.graal.python.test/ — TEST SUITES + +## OVERVIEW +Python-level tests, tag files, and harnesses used by `mx python-gate` and `mx graalpytest`. + +## WHERE TO LOOK +| Task | Location | Notes | +|------|----------|-------| +| Python tests | `src/tests/` | Main Python tests; includes C-API related tests. | +| Tagged/unittest tiers | `src/tests/unittest_tags/` | Tag files select which stdlib tests should pass. | +| Test runner | `src/runner.py` | Harness for executing Python tests. | +| Test data | `testData/` | Golden files and fixtures. | + +## CONVENTIONS +- Tests are typically run via `mx python-gate --tags ...` rather than invoking pytest directly. +- Use `mx [-d] graalpytest TEST-SELECTOR` to rerun a failing test or selection. + +## ANTI-PATTERNS +- Don’t delete failing tests; fix root causes or update tag selections when behavior intentionally changes. diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestBase.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestBase.java new file mode 100644 index 0000000000..910ee1f198 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestBase.java @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.cext.test; + +import java.lang.management.ManagementFactory; +import java.lang.management.ThreadInfo; +import java.lang.management.ThreadMXBean; +import java.util.ArrayList; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.stream.Collectors; + +import org.graalvm.polyglot.Context; +import org.junit.Assert; + +public class MultithreadedImportTestBase { + private static final int ITERATIONS_LIMIT = 10; + + // This test should be executed in its own process. It tests that there are no deadlocks. We do + // not want to wait for the gate job timeout and timeout the test ourselves after shorter period + // of time, but for that we must not call ExecutorService#close, which would be waiting for the + // threads to finish + @SuppressWarnings("resource") + static void multithreadedImportTest(int numberOfThreads, Context context) { + try { + ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads); + var tasks = new ArrayList>(); + for (String pkg : PACKAGES.trim().split("\n")) { + log("Starting import: %s", pkg); + tasks.add(executor.submit(() -> { + log("Importing %s on thread %s", pkg, Thread.currentThread()); + context.eval("python", "import " + pkg); + })); + } + + int iteration = 0; + while (!tasks.isEmpty() && iteration++ < ITERATIONS_LIMIT) { + log("Iteration %s, looping over remaining %d unfinished tasks", iteration, tasks.size()); + var finishedTasks = tasks.stream().filter(task -> { + try { + task.get(1000, TimeUnit.MILLISECONDS); + return true; + } catch (TimeoutException timeoutEx) { + return false; + } catch (Exception ex) { + log("Caught exception: %s", ex); + throw new RuntimeException(ex); + } + }).collect(Collectors.toCollection(ArrayList::new)); + tasks.removeAll(finishedTasks); + } + + if (tasks.isEmpty()) { + executor.shutdown(); + } else { + // otherwise do not wait for the threads to finish, just dump them and continue to + // fail the assertion below + try { + System.out.println("There are unfinished tasks. This failure is inherently transient. " + + "Please report any failure. Thread dump is below if available:"); + ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean(); + for (ThreadInfo threadInfo : threadMxBean.dumpAllThreads(true, true, 20)) { + System.out.print(threadInfo.toString()); + } + } catch (UnsupportedOperationException ignored) { + } + } + + Assert.assertTrue("Unfinished tasks", tasks.isEmpty()); + log("DONE: %s", MultithreadedImportTestBase.class.getSimpleName()); + } finally { + context.close(true); + } + } + + private static void log(String fmt, Object... args) { + System.out.printf(fmt + "%n", args); + } + + private static final String PACKAGES = """ + csv + configparser + tomllib + hashlib + os + _testcapi + io + time + logging + ctypes + argparse + _sqlite3 + _cpython_sre + threading + multiprocessing + sched + contextvars + json + pyexpat + base64 + html + locale + shlex + venv + ast + re + difflib + zlib + """; +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestJava.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestJava.java new file mode 100644 index 0000000000..1c6f3e8406 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestJava.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.cext.test; + +import static com.oracle.graal.python.cext.test.MultithreadedImportTestBase.multithreadedImportTest; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + +import org.graalvm.polyglot.Context; +import org.junit.Assume; +import org.junit.BeforeClass; +import org.junit.Test; + +public class MultithreadedImportTestJava { + @BeforeClass + public static void setUpClass() { + Assume.assumeTrue(SUPPORTS_PANAMA); + } + + @Test + public void testImportOnMultipleThreads() { + Context context = Context.newBuilder().allowAllAccess(true).option("python.PosixModuleBackend", "java").build(); + multithreadedImportTest(8, context); + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestNative.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestNative.java new file mode 100644 index 0000000000..6d27eedf37 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/MultithreadedImportTestNative.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.cext.test; + +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + +import org.graalvm.polyglot.Context; +import org.junit.Assume; +import org.junit.BeforeClass; +import org.junit.Test; + +public class MultithreadedImportTestNative extends MultithreadedImportTestBase { + @BeforeClass + public static void setUpClass() { + Assume.assumeTrue(SUPPORTS_PANAMA); + } + + @Test + public void testImportOnMultipleThreads() { + Context context = Context.newBuilder().allowAllAccess(true).option("python.PosixModuleBackend", "native").build(); + multithreadedImportTest(32, context); + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/package-info.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/package-info.java new file mode 100644 index 0000000000..ccc300f6ca --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/cext/test/package-info.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/** + * Package for tests that need to run in a separate process due to C extensions usage. Add a + * dedicated TestConfig into mx_graalpython#punittest for each test in this package. + */ +package com.oracle.graal.python.cext.test; \ No newline at end of file diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/SocketTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/SocketTests.java index 66d05dc25e..df3344a028 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/SocketTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/SocketTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -74,6 +74,7 @@ import static com.oracle.graal.python.runtime.PosixConstants.SO_TYPE; import static com.oracle.graal.python.runtime.PosixConstants.TCP_NODELAY; import static com.oracle.graal.python.runtime.PosixConstants.TCP_USER_TIMEOUT; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; import static com.oracle.graal.python.util.PythonUtils.toTruffleStringUncached; import static org.hamcrest.CoreMatchers.anyOf; import static org.hamcrest.CoreMatchers.equalTo; @@ -97,6 +98,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import com.oracle.graal.python.PythonLanguage; import org.junit.Assert; import org.junit.Before; import org.junit.Rule; @@ -108,7 +110,7 @@ import org.junit.runners.Parameterized.Parameter; import org.junit.runners.Parameterized.Parameters; -import com.oracle.graal.python.builtins.PythonOS; +import com.oracle.graal.python.annotations.PythonOS; import com.oracle.graal.python.builtins.objects.exception.OSErrorEnum; import com.oracle.graal.python.runtime.PosixConstants.MandatoryIntConstant; import com.oracle.graal.python.runtime.PosixSupportLibrary; @@ -122,6 +124,7 @@ import com.oracle.graal.python.runtime.PosixSupportLibrary.Inet6SockAddr; import com.oracle.graal.python.runtime.PosixSupportLibrary.InvalidAddressException; import com.oracle.graal.python.runtime.PosixSupportLibrary.InvalidUnixSocketPathException; +import com.oracle.graal.python.runtime.PosixSupportLibrary.PosixErrnoException; import com.oracle.graal.python.runtime.PosixSupportLibrary.PosixException; import com.oracle.graal.python.runtime.PosixSupportLibrary.RecvfromResult; import com.oracle.graal.python.runtime.PosixSupportLibrary.SelectResult; @@ -140,7 +143,7 @@ public class SocketTests { @Parameters(name = "{0}") public static String[] params() { - return new String[]{"native", "java"}; + return SUPPORTS_PANAMA ? new String[]{"java", "native"} : new String[]{"java"}; } @Rule public WithPythonContextRule withPythonContextRule = new WithPythonContextRule((o) -> o.put("python.PosixModuleBackend", backendName)); @@ -169,20 +172,20 @@ public void setUp() { } @Test - public void fillUniversalSockAddrInet4() { + public void fillUniversalSockAddrInet4() throws PosixException { Inet4SockAddr addr = new Inet4SockAddr(12345, INADDR_LOOPBACK.value); checkUsa(addr, createUsa(addr)); } @Test - public void fillUniversalSockAddrInet6() { + public void fillUniversalSockAddrInet6() throws PosixException { assumeTrue(isInet6Supported()); Inet6SockAddr addr = new Inet6SockAddr(12345, IN6ADDR_LOOPBACK, 12, 1); checkUsa(addr, createUsa(addr)); } @Test - public void fillUniversalSockAddrUnix() { + public void fillUniversalSockAddrUnix() throws PosixException { assumeTrue("native".equals(backendName)); byte[] path = new byte[]{65, 0}; UnixSockAddr addr = new UnixSockAddr(path); @@ -503,9 +506,9 @@ public void dgramUnconnectedGetpeername() { @Test public void dgramListen() { - expectErrno(() -> { - lib.listen(posixSupport, new UdpServer(AF_INET.value).fd, 5); - }, OSErrorEnum.EOPNOTSUPP); + expectErrno(() -> lib.listen(posixSupport, new UdpServer(AF_INET.value).fd, 5), + OSErrorEnum.EOPNOTSUPP, + OSErrorEnum.EACCES /* Some CI machines seem to block this with EACCESS */); } @Test @@ -637,7 +640,7 @@ public void nonBlockingAccept() throws PosixException { lib.accept(posixSupport, srv.fd); fail("Expected accept() to fail with EWOULDBLOCK"); } catch (PosixException e) { - assertEquals(OSErrorEnum.EWOULDBLOCK.getNumber(), e.getErrorCode()); + assertTrue(e.hasErrno(OSErrorEnum.EWOULDBLOCK)); } cli.connect(srv.usa()); srv.accept(cli.address()); @@ -661,7 +664,7 @@ public void dgramSelect() throws PosixException { @Test public void streamSelect() throws PosixException { - if (PythonOS.getPythonOS() == PythonOS.PLATFORM_DARWIN) { + if (PythonLanguage.getPythonOS() == PythonOS.PLATFORM_DARWIN) { // transiently fails on darwin, skip return; } @@ -697,7 +700,7 @@ public void streamSelect() throws PosixException { } @Test - public void getnameinfo() throws GetAddrInfoException { + public void getnameinfo() throws PosixException, GetAddrInfoException { Object[] res = lib.getnameinfo(posixSupport, createUsa(new Inet6SockAddr(443, IN6ADDR_LOOPBACK, 0, 0)), NI_NUMERICSERV.value | NI_NUMERICHOST.value); assertThat(p2s(res[0]), anyOf(equalTo("::1"), equalTo("0:0:0:0:0:0:0:1%0"))); assertEquals("443", p2s(res[1])); @@ -711,7 +714,7 @@ public void getnameinfo() throws GetAddrInfoException { } @Test - public void getnameinfoUdp() throws GetAddrInfoException { + public void getnameinfoUdp() throws PosixException, GetAddrInfoException { assumeTrue(runsOnLinux()); Object[] res = lib.getnameinfo(posixSupport, createUsa(new Inet4SockAddr(512, INADDR_LOOPBACK.value)), NI_NUMERICHOST.value); assertEquals("exec", p2s(res[1])); @@ -773,7 +776,7 @@ public void getaddrinfoBadFlags() { } @Test - public void getaddrinfoServiceOnly() throws GetAddrInfoException { + public void getaddrinfoServiceOnly() throws PosixException, GetAddrInfoException { Object service = s2p("https"); AddrInfoCursor aic = lib.getaddrinfo(posixSupport, null, service, AF_UNSPEC.value, SOCK_STREAM.value, 0, 0); cleanup.add(() -> aicLib.release(aic)); @@ -794,7 +797,7 @@ public void getaddrinfoServiceOnly() throws GetAddrInfoException { } @Test - public void getaddrinfoPassive() throws GetAddrInfoException { + public void getaddrinfoPassive() throws PosixException, GetAddrInfoException { Object service = s2p("https"); AddrInfoCursor aic = lib.getaddrinfo(posixSupport, null, service, AF_INET.value, 0, IPPROTO_TCP.value, AI_PASSIVE.value); cleanup.add(() -> aicLib.release(aic)); @@ -810,7 +813,7 @@ public void getaddrinfoPassive() throws GetAddrInfoException { } @Test - public void getaddrinfoServerOnlyNoCanon() throws GetAddrInfoException { + public void getaddrinfoServerOnlyNoCanon() throws PosixException, GetAddrInfoException { Object node = s2p("localhost"); AddrInfoCursor aic = lib.getaddrinfo(posixSupport, node, null, AF_UNSPEC.value, SOCK_DGRAM.value, 0, 0); cleanup.add(() -> aicLib.release(aic)); @@ -830,7 +833,7 @@ public void getaddrinfoServerOnlyNoCanon() throws GetAddrInfoException { } @Test - public void getaddrinfo() throws GetAddrInfoException { + public void getaddrinfo() throws PosixException, GetAddrInfoException { Object node = s2p("localhost"); Object service = s2p("https"); AddrInfoCursor aic = lib.getaddrinfo(posixSupport, node, service, AF_INET.value, 0, IPPROTO_TCP.value, AI_CANONNAME.value); @@ -1065,7 +1068,7 @@ private String p2s(Object p) { } private static void expectErrno(ThrowingRunnable runnable, OSErrorEnum... expectedErrorCodes) { - PosixException exception = Assert.assertThrows(PosixException.class, runnable); + PosixErrnoException exception = Assert.assertThrows(PosixErrnoException.class, runnable); if (Stream.of(expectedErrorCodes).noneMatch(e -> exception.getErrorCode() == e.getNumber())) { String names = Stream.of(expectedErrorCodes).map(OSErrorEnum::name).collect(Collectors.joining(" or ")); fail("Expected PosixException with error code " + names + " but the actual error code was " + exception.getErrorCode() + " (" + exception + ")"); @@ -1085,7 +1088,7 @@ private int createSocket(int family, int type, int protocol) throws PosixExcepti return sockfd; } - private UniversalSockAddr createUsa(FamilySpecificSockAddr src) { + private UniversalSockAddr createUsa(FamilySpecificSockAddr src) throws PosixException { if (src instanceof Inet4SockAddr inet4SockAddr) { return lib.createUniversalSockAddrInet4(posixSupport, inet4SockAddr); } else if (src instanceof Inet6SockAddr inet6SockAddr) { diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/CompilerFailureExitTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/CompilerFailureExitTest.java new file mode 100644 index 0000000000..3185a36e8f --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/CompilerFailureExitTest.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.advanced; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.Engine; +import org.junit.Assume; +import org.junit.Test; + +public class CompilerFailureExitTest { + private static final String ENABLE_FLAG_ENV_NAME = "GRAALPYTHON_JUNIT_COMPILER_FAILURE_EXIT_TEST"; + + @Test + public void compilerBailoutExitsVM() { + Assume.assumeTrue(ENABLE_FLAG_ENV_NAME + " is not set", "true".equals(System.getenv(ENABLE_FLAG_ENV_NAME))); + try (Engine engine = Engine.newBuilder("python").allowExperimentalOptions(true).// + option("engine.BackgroundCompilation", "false").// + option("engine.FirstTierCompilationThreshold", "1").// + option("engine.LastTierCompilationThreshold", "10").build(); + Context context = Context.newBuilder("python").engine(engine).allowExperimentalOptions(true).allowAllAccess(true).// + option("python.EnableDebuggingBuiltins", "true").build()) { + context.eval("python", """ + import __graalpython__ + + def trigger_compiler_bailout(): + for _ in range(100): + __graalpython__.compiler_bailout_for_tests() + + trigger_compiler_bailout() + """); + } + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/LeakTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/LeakTest.java index 2110a7dfc3..ce8438d096 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/LeakTest.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/advanced/LeakTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -66,7 +66,9 @@ import org.netbeans.lib.profiler.heap.HeapFactory; import org.netbeans.lib.profiler.heap.Instance; import org.netbeans.lib.profiler.heap.JavaClass; +import org.netbeans.lib.profiler.heap.ObjectArrayInstance; +import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.HandleContext; import com.oracle.graal.python.test.integration.Utils; import com.sun.management.HotSpotDiagnosticMXBean; @@ -100,6 +102,7 @@ public static void main(String[] args) { private boolean keepDump = false; private int repeatAndCheckSize = -1; private boolean nullStdout = false; + private boolean forbidCApiResidue = false; private String languageId; private String code; private List forbiddenClasses = new ArrayList<>(); @@ -161,19 +164,100 @@ private boolean checkForLeaks(Path dumpFile) { } } } + if (forbidCApiResidue && checkCApiResidue(heap)) { + fail = true; + } } catch (IOException e) { throw new RuntimeException(e); } return fail; } + private boolean checkCApiResidue(Heap heap) { + JavaClass cls = heap.getJavaClassByName(HandleContext.class.getName()); + if (cls == null) { + System.err.println("Could not find " + HandleContext.class.getName() + " in heap dump"); + return true; + } + boolean fail = false; + for (Object i : cls.getInstances()) { + Instance inst = (Instance) i; + if (!isReachable(inst)) { + continue; + } + List residues = new ArrayList<>(); + addResidue(residues, inst, "referencesToBeFreed", this::collectionSize); + addResidue(residues, inst, "nativeLookup", this::collectionSize); + addResidue(residues, inst, "nativeWeakRef", this::collectionSize); + addResidue(residues, inst, "managedNativeLookup", this::collectionSize); + addResidue(residues, inst, "nativeTypeLookup", this::objectArraySize); + addResidue(residues, inst, "nativeStubLookup", this::objectArraySize); + addResidue(residues, inst, "nativeStorageReferences", this::collectionSize); + addResidue(residues, inst, "pyCapsuleReferences", this::collectionSize); + if (!residues.isEmpty()) { + fail = true; + System.err.println("C API residue in reachable HandleContext " + inst.getInstanceId() + ": " + + String.join(", ", residues)); + } + } + return fail; + } + + private void addResidue(List residues, Instance inst, String name, FieldSize fieldSize) { + Object fieldValue = inst.getValueOfField(name); + if (fieldValue == null) { + residues.add(name + "=missing"); + return; + } + int size = fieldSize.apply(fieldValue); + if (size > 0) { + residues.add(name + "=" + size); + } + } + + @FunctionalInterface + private interface FieldSize { + int apply(Object object); + } + + private int collectionSize(Object object) { + if (object instanceof Instance instance) { + Object size = instance.getValueOfField("size"); + if (size instanceof Number n) { + return n.intValue(); + } + Object baseCount = instance.getValueOfField("baseCount"); + if (baseCount instanceof Number n) { + return n.intValue(); + } + Object map = instance.getValueOfField("map"); + if (map instanceof Instance mapInstance) { + return collectionSize(mapInstance); + } + } + return 0; + } + + private int objectArraySize(Object object) { + if (object instanceof ObjectArrayInstance array) { + int size = 0; + for (Object value : array.getValues()) { + if (value != null) { + size++; + } + } + return size; + } + return 0; + } + private int getCntAndErrors(JavaClass cls, List errors) { int cnt = cls.getInstancesCount(); if (cnt > 0) { boolean realLeak = false; for (Object i : cls.getInstances()) { Instance inst = (Instance) i; - if (inst.isGCRoot() || inst.getNearestGCRootPointer() != null) { + if (isReachable(inst)) { realLeak = true; break; } @@ -188,6 +272,10 @@ private int getCntAndErrors(JavaClass cls, List errors) { return cnt; } + private boolean isReachable(Instance inst) { + return inst.isGCRoot() || inst.getNearestGCRootPointer() != null; + } + @SuppressWarnings("sync-override") @Override public final Throwable fillInStackTrace() { @@ -271,6 +359,8 @@ protected List preprocessArguments(List arguments, Map initialSize * 1.1) { + if (currentSize > initialSize * 1.15) { System.err.printf("Heap size grew too much after repeated context creations and invocations. From %,d bytes to %,d bytes.\n", initialSize, currentSize); if (keepDump) { dumpHeap(ManagementFactory.getPlatformMBeanServer(), true); @@ -346,13 +436,9 @@ protected String getLanguageId() { return languageId; } - @Override - protected String[] getDefaultLanguages() { - return new String[]{languageId}; - } - @Override protected void printHelp(OptionCategory maxCategory) { - System.out.println("--lang ID --code CODE --forbidden-class FQN [--forbidden-class FQN]* [--shared-engine] [--keep-dump] [POLYGLOT-OPTIONS]"); + System.out.println("--lang ID --code CODE --forbidden-class FQN [--forbidden-class FQN]* " + + "[--forbid-capi-residue] [--shared-engine] [--keep-dump] [POLYGLOT-OPTIONS]"); } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ClinicTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ClinicTests.java index 5d82ba2115..6ffc46b251 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ClinicTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ClinicTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -57,11 +57,10 @@ import com.oracle.graal.python.annotations.ClinicConverterFactory.BuiltinName; import com.oracle.graal.python.annotations.ClinicConverterFactory.DefaultValue; import com.oracle.graal.python.annotations.ClinicConverterFactory.UseDefaultForNone; -import com.oracle.graal.python.builtins.Builtin; +import com.oracle.graal.python.annotations.Builtin; import com.oracle.graal.python.builtins.PythonBuiltinClassType; import com.oracle.graal.python.builtins.objects.PNone; import com.oracle.graal.python.builtins.objects.function.PArguments; -import com.oracle.graal.python.builtins.objects.function.PKeyword; import com.oracle.graal.python.nodes.argument.ReadArgumentNode; import com.oracle.graal.python.nodes.argument.ReadIndexedArgumentNode; import com.oracle.graal.python.nodes.argument.ReadVarArgsNode; @@ -211,15 +210,15 @@ public void testVarArgDefaultValues() { new ReadArgumentNode[]{ ReadIndexedArgumentNode.create(0), ReadIndexedArgumentNode.create(1), - ReadVarArgsNode.create(true), + ReadVarArgsNode.create(3), ReadIndexedArgumentNode.create(2) })); - Object[] scope_w = PArguments.create(2); - scope_w[PArguments.USER_ARGUMENTS_OFFSET] = "abc"; - scope_w[PArguments.USER_ARGUMENTS_OFFSET + 1] = 42; - PArguments.setVariableArguments(scope_w, 666); - PArguments.setKeywordArguments(scope_w, new PKeyword[]{new PKeyword(tsLiteral("b"), PNone.NO_VALUE)}); - assertEquals(666, callTarget.call(scope_w)); + Object[] pArguments = PArguments.create(4); + PArguments.setArgument(pArguments, 0, "abc"); + PArguments.setArgument(pArguments, 1, 42); + PArguments.setArgument(pArguments, 2, PNone.NO_VALUE); + PArguments.setArgument(pArguments, 3, new Object[]{666}); + assertEquals(666, callTarget.call(pArguments)); } private static CallTarget createCallTarget(PythonBinaryClinicBuiltinNode node) { diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ConversionNodeTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ConversionNodeTests.java index 2f710639c4..4391f3b03f 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ConversionNodeTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/ConversionNodeTests.java @@ -76,7 +76,7 @@ protected static Object call(Object arg, ArgumentCastNode castNode) { public Object execute(VirtualFrame frame) { GilNode gilNode = GilNode.getUncached(); boolean wasAcquired = gilNode.acquire(); - calleeContext.enter(frame); + calleeContext.enter(frame, this); try { return node.execute(frame, PArguments.getArgument(frame, 0)); } finally { @@ -101,7 +101,7 @@ public boolean isPythonInternal() { PArguments.setException(arguments, PException.NO_EXCEPTION); PArguments.setArgument(arguments, 0, arg); PythonThreadState threadState = pythonContext.getThreadState(language); - Object state = IndirectCalleeContext.enter(threadState, arguments, callTarget); + Object state = IndirectCalleeContext.enter(threadState, arguments); try { return CallDispatchers.SimpleIndirectInvokeNode.executeUncached(callTarget, arguments); } finally { diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/PathConversionNodeTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/PathConversionNodeTests.java index 387006db46..f6d9b140f8 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/PathConversionNodeTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/PathConversionNodeTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -42,6 +42,7 @@ import static com.oracle.graal.python.test.PythonTests.ts; import static com.oracle.graal.python.test.integration.Utils.IS_WINDOWS; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; import static com.oracle.graal.python.util.PythonUtils.TS_ENCODING; import java.math.BigInteger; @@ -83,7 +84,7 @@ public class PathConversionNodeTests extends ConversionNodeTests { @Parameters(name = "{0}") public static String[] params() { - return new String[]{"java", "native"}; + return SUPPORTS_PANAMA ? new String[]{"java", "native"} : new String[]{"java"}; } @Before diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/TimeModuleTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/TimeModuleTests.java new file mode 100644 index 0000000000..4579a8ad7d --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/modules/TimeModuleTests.java @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.builtin.modules; + +import static org.junit.Assert.assertEquals; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.TimeZone; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.Source; +import org.junit.Test; + +public class TimeModuleTests { + + @Test + public void strftimeTimezoneMatchesTzsetState() { + TimeZone previousDefault = TimeZone.getDefault(); + try { + TimeZone.setDefault(TimeZone.getTimeZone("Europe/Berlin")); + String result; + try (Context context = Context.newBuilder("python").allowAllAccess(true).build()) { + result = context.eval(Source.create("python", """ + import os + import time + + os.environ["TZ"] = "UTC" + time.tzset() + tt = time.localtime() + + "\\n".join(( + f"tm_zone={tt.tm_zone}", + f"tzname={time.tzname[tt.tm_isdst > 0]}", + f"strftime_tuple={time.strftime('%Z', tt)}", + f"strftime_now={time.strftime('%Z')}", + )) + """)).asString(); + } + + Map values = parseKeyValueLines(result); + String details = values.toString(); + assertEquals(details, values.get("tm_zone"), values.get("tzname")); + assertEquals(details, values.get("tm_zone"), values.get("strftime_tuple")); + assertEquals(details, values.get("tm_zone"), values.get("strftime_now")); + } finally { + TimeZone.setDefault(previousDefault); + } + } + + private static Map parseKeyValueLines(String output) { + Map values = new LinkedHashMap<>(); + for (String line : output.split("\\R")) { + int separator = line.indexOf('='); + values.put(line.substring(0, separator), line.substring(separator + 1)); + } + return values; + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/TpSlotsTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/TpSlotsTests.java index 15edba3d06..5e008508c1 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/TpSlotsTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/TpSlotsTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,27 +40,51 @@ */ package com.oracle.graal.python.test.builtin.objects; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + import java.util.EnumSet; +import org.junit.After; import org.junit.Assert; +import org.junit.Assume; +import org.junit.Before; +import org.junit.BeforeClass; import org.junit.Test; +import com.oracle.graal.python.annotations.NativeSimpleType; import com.oracle.graal.python.builtins.objects.type.TpSlots; import com.oracle.graal.python.builtins.objects.type.TpSlots.Builder; import com.oracle.graal.python.builtins.objects.type.TpSlots.TpSlotGroup; import com.oracle.graal.python.builtins.objects.type.TpSlots.TpSlotMeta; import com.oracle.graal.python.builtins.objects.type.slots.TpSlot; import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotNative; +import com.oracle.graal.python.runtime.nativeaccess.NativeContext; +import com.oracle.graal.python.runtime.nativeaccess.NativeFunctionPointer; import com.oracle.graal.python.util.Function; public class TpSlotsTests { + private NativeContext nativeContext; + + @BeforeClass + public static void setUpClass() { + Assume.assumeTrue(SUPPORTS_PANAMA); + } + + @Before + public void setUp() { + nativeContext = NativeContext.create(); + } + + @After + public void tearDown() { + nativeContext.close(); + } + @Test public void testBuilderBasic() { Builder builder = TpSlots.newBuilder(); for (TpSlotMeta def : TpSlotMeta.VALUES) { - // Use the TpSlotMeta as dummy "callable" object to verify that the slot values were - // properly assigned to the right fields of TpSlots record - builder.set(def, TpSlotNative.createCExtSlot(def)); + builder.set(def, createCExtSlot(def)); } TpSlots slots = builder.build(); @@ -95,9 +119,9 @@ public void testBuilderExplicitGroup() { @Test public void testBuilderOptimizations1() { Builder builder = TpSlots.newBuilder(); - builder.set(TpSlotMeta.MP_LENGTH, TpSlotNative.createCExtSlot(TpSlotMeta.MP_LENGTH)); - builder.set(TpSlotMeta.TP_GETATTR, TpSlotNative.createCExtSlot(TpSlotMeta.TP_GETATTR)); - builder.set(TpSlotMeta.TP_SETATTR, TpSlotNative.createCExtSlot(TpSlotMeta.TP_SETATTR)); + builder.set(TpSlotMeta.MP_LENGTH, createCExtSlot(TpSlotMeta.MP_LENGTH)); + builder.set(TpSlotMeta.TP_GETATTR, createCExtSlot(TpSlotMeta.TP_GETATTR)); + builder.set(TpSlotMeta.TP_SETATTR, createCExtSlot(TpSlotMeta.TP_SETATTR)); TpSlots slots = builder.build(); verifySlots(slots, def -> def == TpSlotMeta.MP_LENGTH || def == TpSlotMeta.TP_GETATTR || def == TpSlotMeta.TP_SETATTR); @@ -111,7 +135,7 @@ public void testBuilderOptimizations1() { @Test public void testBuilderOptimizations2() { Builder builder = TpSlots.newBuilder(); - builder.set(TpSlotMeta.SQ_LENGTH, TpSlotNative.createCExtSlot(TpSlotMeta.SQ_LENGTH)); + builder.set(TpSlotMeta.SQ_LENGTH, createCExtSlot(TpSlotMeta.SQ_LENGTH)); TpSlots slots = builder.build(); verifySlots(slots, def -> def == TpSlotMeta.SQ_LENGTH); @@ -137,8 +161,16 @@ private static void verifySlots(TpSlots slots, Function che } } + // Use the TpSlotMeta's ordinal value as a pointer for creating a dummy native function pointer + // to + // verify that the slot values were properly assigned to the right fields of TpSlots + // record + private TpSlotNative createCExtSlot(TpSlotMeta def) { + return TpSlotNative.createCExtSlot(NativeFunctionPointer.create(nativeContext, def.ordinal(), NativeSimpleType.VOID)); + } + private static void checkSlotValue(TpSlotMeta def, TpSlot slotValue) { - Assert.assertTrue(def.name(), slotValue instanceof TpSlotNative slotNative && slotNative.getCallable() == def); + Assert.assertTrue(def.name(), slotValue instanceof TpSlotNative slotNative && slotNative.getCallable().getAddress() == def.ordinal()); } private static boolean getGroup(TpSlots slots, TpSlotGroup group) { diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/CExtContextTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/CExtContextTest.java index ea13747810..5988f5c1bb 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/CExtContextTest.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/CExtContextTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -47,6 +47,7 @@ import org.junit.Test; import com.oracle.graal.python.builtins.objects.cext.common.CExtContext; +import com.oracle.graal.python.runtime.nativeaccess.NativeLibrary; import com.oracle.graal.python.runtime.PythonContext; import com.oracle.graal.python.test.PythonTests; import com.oracle.truffle.api.strings.TruffleString; @@ -80,8 +81,8 @@ public void testGetBaseName() { } private static class TestCExtContext extends CExtContext { - public TestCExtContext(PythonContext context, Object library) { - super(context, library); + public TestCExtContext(PythonContext context, NativeLibrary library) { + super(context, library, null); } public static TruffleString getBN(TruffleString s) { diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/SlotWrapperTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/SlotWrapperTests.java index fb0c70913d..9970dc920c 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/SlotWrapperTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/SlotWrapperTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,16 +40,26 @@ */ package com.oracle.graal.python.test.builtin.objects.cext; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.not; import static org.hamcrest.MatcherAssert.assertThat; +import java.util.Map; + +import org.junit.After; +import org.junit.Assume; +import org.junit.Before; +import org.junit.BeforeClass; import org.junit.Test; -import com.oracle.graal.python.builtins.objects.cext.capi.PyProcsWrapper.TpSlotWrapper; +import com.oracle.graal.python.builtins.objects.cext.capi.CApiContext; +import com.oracle.graal.python.builtins.objects.cext.capi.TpSlotWrapper; import com.oracle.graal.python.builtins.objects.type.TpSlots.TpSlotMeta; import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotPythonSingle; +import com.oracle.graal.python.runtime.GilNode; +import com.oracle.graal.python.test.PythonTests; import com.oracle.graal.python.util.PythonUtils; import com.oracle.truffle.api.strings.TruffleString; @@ -58,6 +68,27 @@ public class SlotWrapperTests { private static final Object DUMMY_CALLABLE = new Object(); private static final Object DUMMY_TYPE = new Object(); + private GilNode.UncachedAcquire gil; + + @BeforeClass + public static void setUpClass() { + Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("mac")); + Assume.assumeTrue(SUPPORTS_PANAMA); + } + + @Before + public void setUp() { + PythonTests.enterContext(Map.of("python.IsolateNativeModules", "true"), new String[0]); + gil = GilNode.uncachedAcquire(); + CApiContext.ensureCapiWasLoaded("test slot wrapper"); + } + + @After + public void tearDown() { + gil.close(); + PythonTests.closeContext(); + } + @Test public void testCloneContract() { TruffleString testName = PythonUtils.toTruffleStringUncached("__test__"); diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/dict/PDictTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/dict/PDictTest.java index 30450f9d61..be6ce8d515 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/dict/PDictTest.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/dict/PDictTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2022, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -98,6 +98,7 @@ public void economicMapStorageSet() { dict.setItem(ts("key1"), 42); assertEquals(2, length(dict)); + assertTrue(dict.getDictStorage() instanceof EconomicMapStorage); assertEquals(42, dict.getItem(ts("key1"))); } @@ -113,9 +114,20 @@ public void economicMapStorageDel() { delItem(dict, ts("key2")); assertEquals(2, length(dict)); + assertTrue(dict.getDictStorage() instanceof EconomicMapStorage); assertEquals(42, dict.getItem(ts("key1"))); assertNull(dict.getItem(ts("key2"))); } + + @Test + public void economicMapStorageEightEntries() { + PDict dict = PFactory.createDict(PythonLanguage.get(null)); + for (int i = 0; i < 8; i++) { + dict.setItem(i, i); + } + assertTrue(dict.getDictStorage() instanceof EconomicMapStorage); + assertEquals(8, length(dict)); + } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/debug/PythonDebugTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/debug/PythonDebugTest.java index e18a7f9ae5..1d8b5fa3f6 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/debug/PythonDebugTest.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/debug/PythonDebugTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,6 +40,7 @@ */ package com.oracle.graal.python.test.debug; +import static com.oracle.graal.python.test.integration.PythonTests.eval; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -59,7 +60,6 @@ import org.graalvm.polyglot.Context.Builder; import org.graalvm.polyglot.Source; import org.junit.After; -import org.junit.Assume; import org.junit.Before; import org.junit.Test; @@ -82,6 +82,7 @@ public void before() { Builder newBuilder = Context.newBuilder(); newBuilder.allowExperimentalOptions(true); newBuilder.allowAllAccess(true); + newBuilder.option("engine.WarnInterpreterOnly", "false"); PythonTests.closeContext(); tester = new DebuggerTester(newBuilder); } @@ -93,9 +94,9 @@ public void dispose() { @Test public void testSteppingAsExpected() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); // test that various elements step as expected, including generators, statement level atomic // expressions, and roots + boolean isBytecodeDLS = isBytecodeDSL(); final Source source = Source.newBuilder("python", "" + "import sys\n" + "from sys import version\n" + @@ -160,16 +161,30 @@ public void testSteppingAsExpected() throws Throwable { assertEquals(7, frame.getSourceSection().getStartLine()); event.prepareStepOver(1); }); + // for i in >genfunc()<: expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); assertEquals(8, frame.getSourceSection().getStartLine()); event.prepareStepInto(1); }); - expectSuspended((SuspendedEvent event) -> { - DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(12, frame.getSourceSection().getStartLine()); - event.prepareStepOver(1); - }); + // Unlike the manual interpreter, which reports yield as onReturn, the Bytecode DSL + // correctly reports yield as onYield on the probe node, but the step over strategy + // is different for yield vs return - see SteppingStrategy$StepOver#step + if (!isBytecodeDLS) { + // steppping into genfunc() + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(12, frame.getSourceSection().getStartLine()); + event.prepareStepOver(1); + }); + } else { + // steppping into genfunc() + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(12, frame.getSourceSection().getStartLine()); + event.prepareStepOut(1); + }); + } expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); assertEquals(8, frame.getSourceSection().getStartLine()); @@ -186,7 +201,6 @@ public void testSteppingAsExpected() throws Throwable { @Test public void testException() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "try:\n" + " 1 / 0\n" + @@ -210,64 +224,52 @@ public void testException() throws Throwable { @Test public void testInlineEvaluation() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "y = 4\n" + "def foo(x):\n" + " a = 1\n" + " b = 2\n" + - " def bar():\n" + + " q = 42\n" + + " def bar(z = 24):\n" + " return a + b\n" + " return bar() + x + y\n" + "foo(3)", "test_inline.py").buildLiteral(); try (DebuggerSession session = tester.startSession()) { - session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(5).build()); + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(6).build()); session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(7).build()); + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(8).build()); tester.startEval(source); + // breakpoint at bar declaration expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(5, frame.getSourceSection().getStartLine()); + assertEquals("42", frame.eval("q").toDisplayString()); assertEquals("3", frame.eval("a + b").toDisplayString()); + assertEquals(6, frame.getSourceSection().getStartLine()); event.prepareContinue(); }); + // breakpoint at bar call site expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(7, frame.getSourceSection().getStartLine()); + assertEquals(8, frame.getSourceSection().getStartLine()); assertEquals("6", frame.eval("bar() * 2").toDisplayString()); event.prepareContinue(); }); - assertEquals("10", tester.expectDone()); - } - } - - @Test - @SuppressWarnings("try") - public void testBreakpointBuiltin() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); - final Source source = Source.newBuilder("python", "" + - "def foo():\n" + - " a = 1\n" + - " breakpoint()\n" + - " return 1\n" + - "foo()\n", "test_breakpoint_builtin.py").buildLiteral(); - - try (DebuggerSession session = tester.startSession()) { - tester.startEval(source); - + // breakpoint inside bar expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(3, frame.getSourceSection().getStartLine()); + assertEquals("24", frame.eval("z").toDisplayString()); + assertEquals("3", frame.eval("a + b").toDisplayString()); + assertEquals(7, frame.getSourceSection().getStartLine()); event.prepareContinue(); }); - assertEquals("1", tester.expectDone()); + assertEquals("10", tester.expectDone()); } } @Test public void testConditionalBreakpointInFunction() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "def fun():\n" + " def prod(n):\n" + @@ -313,7 +315,6 @@ public void testConditionalBreakpointInFunction() throws Throwable { @Test public void testConditionalBreakpointGlobal() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "values = []\n" + "for i in range(0, 10):\n" + @@ -335,9 +336,52 @@ public void testConditionalBreakpointGlobal() throws Throwable { } } + @Test + public void testGeneralLocals() throws Throwable { + final Source source = Source.newBuilder("python", """ + def gen_fun(a, b): + yield 1 + c = 3 + yield 2 + r = 0 + for i in gen_fun(1,2): + r += i + r + """, "testGeneratorLocals.py").buildLiteral(); + + try (DebuggerSession session = tester.startSession()) { + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(2).build()); + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(4).build()); + tester.startEval(source); + + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(2, frame.getSourceSection().getStartLine()); + checkStack(frame, "gen_fun", "a", "1", "b", "2"); + event.prepareContinue(); + }); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(2, frame.getSourceSection().getStartLine()); + event.prepareContinue(); + }); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(4, frame.getSourceSection().getStartLine()); + checkStack(frame, "gen_fun", "a", "1", "b", "2", "c", "3"); + event.prepareContinue(); + }); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(4, frame.getSourceSection().getStartLine()); + event.prepareContinue(); + }); + assertEquals("3", tester.expectDone()); + } + } + @Test public void testReenterArgumentsAndValues() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); // Test that after a re-enter, arguments are kept and variables are cleared. final Source source = Source.newBuilder("python", "" + "def main():\n" + @@ -365,7 +409,7 @@ public void testReenterArgumentsAndValues() throws Throwable { expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(6, frame.getSourceSection().getStartLine()); + assertEquals("first breakpoint at 6", 6, frame.getSourceSection().getStartLine()); checkStack(frame, "fnc", "n", "11", "m", "20"); event.prepareStepOver(4); }); @@ -382,7 +426,7 @@ public void testReenterArgumentsAndValues() throws Throwable { }); expectSuspended((SuspendedEvent event) -> { DebugStackFrame frame = event.getTopStackFrame(); - assertEquals(6, frame.getSourceSection().getStartLine()); + assertEquals("first breakpoint at 6", 6, frame.getSourceSection().getStartLine()); checkStack(frame, "fnc", "n", "11", "m", "20"); }); assertEquals("50.0", tester.expectDone()); @@ -392,7 +436,6 @@ public void testReenterArgumentsAndValues() throws Throwable { @Test @SuppressWarnings("deprecation") public void testGettersSetters() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "class GetterOnly:\n" + " def __get__(self):\n" + @@ -462,7 +505,6 @@ public void testGettersSetters() throws Throwable { @Test public void testInspectJavaArray() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); final Source source = Source.newBuilder("python", "" + "import java\n" + "a_int = java.type('int[]')(3)\n" + @@ -508,9 +550,17 @@ public void testInspectJavaArray() throws Throwable { @Test public void testSourceFileURI() throws Throwable { - Assume.assumeFalse("TODO: debugger tests are broken on Bytecode DSL", Boolean.getBoolean("python.EnableBytecodeDSLInterpreter")); + testSourceFileURIImpl(false); + } + + @Test + public void testSourceFileURIBytecode() throws Throwable { + testSourceFileURIImpl(true); + } + + private void testSourceFileURIImpl(boolean runFromBytecode) throws Throwable { if (System.getProperty("os.name").toLowerCase().contains("mac")) { - // on the mac machines we run with symlinked directories and such and it's annoying to + // on the mac machines we run with symlinked directories and such, and it's annoying to // cater for that return; } @@ -524,6 +574,11 @@ public void testSourceFileURI() throws Throwable { "sys.path.insert(0, '" + tempDir.toString() + "')\n" + "import imported\n" + "imported.sum(2, 3)\n").getBytes()); + + if (runFromBytecode) { + compileToBytecode(importedFile, importingFile); + } + Source source = Source.newBuilder("python", importingFile.toFile()).build(); try (DebuggerSession session = tester.startSession()) { Breakpoint breakpoint = Breakpoint.newBuilder(importingFile.toUri()).lineIs(4).build(); @@ -561,6 +616,47 @@ public void testSourceFileURI() throws Throwable { } } + private void compileToBytecode(Path... files) { + StringBuilder sourceCode = new StringBuilder("import py_compile\n"); + for (Path file : files) { + sourceCode.append("py_compile.compile(r\"").append(file).append("\")\n"); + } + Source compileSource = Source.newBuilder("python", sourceCode.toString(), "compile_source_uri.py").buildLiteral(); + tester.startEval(compileSource); + tester.expectDone(); + } + + @Test + public void testInlineEvaluationBreakpointBuiltin() throws Throwable { + final Source source = Source.newBuilder("python", """ + a = 1 + breakpoint() + b = 2 + breakpoint # not invoking, therefore no breakpoint inserted + """, "test_inline.py").buildLiteral(); + + try (DebuggerSession session = tester.startSession()) { + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(1).build()); + session.install(Breakpoint.newBuilder(DebuggerTester.getSourceImpl(source)).lineIs(3).build()); + tester.startEval(source); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(1, frame.getSourceSection().getStartLine()); + event.prepareContinue(); + }); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(2, frame.getSourceSection().getStartLine()); + event.prepareContinue(); + }); + expectSuspended((SuspendedEvent event) -> { + DebugStackFrame frame = event.getTopStackFrame(); + assertEquals(3, frame.getSourceSection().getStartLine()); + event.prepareContinue(); + }); + } + } + private void expectSuspended(SuspendedCallback callback) { tester.expectSuspended(callback); } @@ -601,4 +697,8 @@ public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOEx } }); } + + private static boolean isBytecodeDSL() { + return eval("__graalpython__.is_bytecode_dsl_interpreter").asBoolean(); + } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/HostInteropTest.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/HostInteropTest.java index ab99e374da..4d54def051 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/HostInteropTest.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/HostInteropTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -46,6 +46,7 @@ import static org.junit.Assert.assertTrue; import java.math.BigInteger; +import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.time.LocalDate; import java.time.LocalTime; @@ -53,6 +54,7 @@ import org.graalvm.polyglot.Context; import org.graalvm.polyglot.Value; +import org.graalvm.polyglot.io.ByteSequence; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -713,4 +715,79 @@ public void testByteBuffer() { t.writeBufferDouble(ByteOrder.LITTLE_ENDIAN, 0, 12345.6789123); assertEquals(12345.6789123, t.readBufferDouble(ByteOrder.LITTLE_ENDIAN, 0), 0.0); } + + @Test + public void testHostByteBufferAsPythonBuffer() { + byte[] writable = new byte[]{1, 2, 3, 4}; + context.getBindings("python").putMember("writable_bb", ByteBuffer.wrap(writable)); + context.getBindings("python").putMember("readonly_bb", ByteBuffer.wrap(new byte[]{-1, 5, 6, 7, 8}).asReadOnlyBuffer()); + + context.eval("python", """ + import binascii + import io + + mv = memoryview(writable_bb) + assert not mv.readonly + assert mv.tobytes() == b"\\x01\\x02\\x03\\x04" + assert bytes(writable_bb) == b"\\x01\\x02\\x03\\x04" + assert bytearray(writable_bb) == bytearray(b"\\x01\\x02\\x03\\x04") + assert binascii.hexlify(writable_bb) == b"01020304" + bio = io.BytesIO() + assert bio.write(writable_bb) == 4 + assert bio.getvalue() == b"\\x01\\x02\\x03\\x04" + mv[1] = 9 + assert io.BytesIO(b"abcd").readinto(writable_bb) == 4 + assert bytes(writable_bb) == b"abcd" + + ro = memoryview(readonly_bb) + assert ro.readonly + assert ro.tobytes() == b"\\xff\\x05\\x06\\x07\\x08" + assert bytes(readonly_bb) == b"\\xff\\x05\\x06\\x07\\x08" + assert bytearray(readonly_bb) == bytearray(b"\\xff\\x05\\x06\\x07\\x08") + assert io.BytesIO().write(readonly_bb) == 5 + try: + ro[0] = 1 + raise AssertionError("expected memoryview write to fail") + except TypeError: + pass + try: + io.BytesIO(b"wxyz").readinto(readonly_bb) + raise AssertionError("expected readinto to fail") + except TypeError: + pass + """); + + assertArrayEquals(new byte[]{'a', 'b', 'c', 'd'}, writable); + } + + @Test + public void testHostByteSequenceAsPythonBuffer() { + byte[] bytes = new byte[]{10, 20, 30, 40}; + context.getBindings("python").putMember("seq", ByteSequence.create(bytes)); + + context.eval("python", """ + import binascii + import io + + mv = memoryview(seq) + assert mv.readonly + assert mv.tobytes() == b"\\x0a\\x14\\x1e\\x28" + assert bytes(seq) == b"\\x0a\\x14\\x1e\\x28" + assert bytearray(seq) == bytearray(b"\\x0a\\x14\\x1e\\x28") + assert binascii.hexlify(seq) == b"0a141e28" + bio = io.BytesIO() + assert bio.write(seq) == 4 + assert bio.getvalue() == b"\\x0a\\x14\\x1e\\x28" + try: + mv[0] = 1 + raise AssertionError("expected memoryview write to fail") + except TypeError: + pass + try: + io.BytesIO(b"abcd").readinto(seq) + raise AssertionError("expected readinto to fail") + except TypeError: + pass + """); + } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/SourceOptionsTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/SourceOptionsTests.java new file mode 100644 index 0000000000..f6acf93a86 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/interop/SourceOptionsTests.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.interop; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.Source; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import com.oracle.graal.python.test.PythonTests; + +public class SourceOptionsTests extends PythonTests { + private Context context; + + @Before + public void setUpTest() { + Context.Builder builder = Context.newBuilder(); + builder.allowExperimentalOptions(true); + builder.allowAllAccess(true); + context = builder.build(); + } + + @After + public void tearDown() { + context.close(); + } + + @Test + public void testDefaultUsesMainModuleGlobals() { + context.eval("python", "x = 41"); + assertEquals(42, context.eval("python", "x + 1").asInt()); + } + + @Test + public void testNewGlobalsIsolatedFromMainModule() throws IOException { + context.eval("python", "x = 41"); + + Source source = Source.newBuilder("python", "x = 100\nx + 1", "new-globals.py").option("python.NewGlobals", "true").build(); + + assertEquals(101, context.eval(source).asInt()); + assertEquals(42, context.eval("python", "x + 1").asInt()); + } + + @Test + public void testSeparateNewGlobalsExecutionsDoNotShareState() throws IOException { + Source writeSource = Source.newBuilder("python", "x = 100", "new-globals-write.py").option("python.NewGlobals", "true").build(); + Source readSource = Source.newBuilder("python", "x = globals().get('x', 0)\nx + 1", "new-globals-read.py").option("python.NewGlobals", "true").build(); + + context.eval(writeSource); + assertEquals(1, context.eval(readSource).asInt()); + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/nodes/MemMoveNodeTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/nodes/MemMoveNodeTests.java index bd47cccece..a9fec087cb 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/nodes/MemMoveNodeTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/nodes/MemMoveNodeTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -40,6 +40,8 @@ */ package com.oracle.graal.python.test.nodes; +import static com.oracle.graal.python.test.integration.Utils.SUPPORTS_PANAMA; + import com.oracle.graal.python.builtins.objects.PNone; import com.oracle.graal.python.builtins.objects.cext.capi.CApiContext; import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodes.MemMoveNode; @@ -68,6 +70,7 @@ public class MemMoveNodeTests { @BeforeClass public static void setUpClass() { Assume.assumeFalse(System.getProperty("os.name").toLowerCase().contains("mac")); + Assume.assumeTrue(SUPPORTS_PANAMA); } @Before @@ -113,10 +116,10 @@ public Object execute(VirtualFrame frame) { }.getCallTarget().call(); - Assert.assertEquals(1, GetItemScalarNode.executeUncached(storage, 0)); - Assert.assertEquals(2, GetItemScalarNode.executeUncached(storage, 1)); - Assert.assertEquals(2, GetItemScalarNode.executeUncached(storage, 2)); - Assert.assertEquals(2, GetItemScalarNode.executeUncached(storage, 3)); - Assert.assertEquals(3, GetItemScalarNode.executeUncached(storage, 4)); + Assert.assertEquals(1L, ((Number) GetItemScalarNode.executeUncached(storage, 0)).longValue()); + Assert.assertEquals(2L, ((Number) GetItemScalarNode.executeUncached(storage, 1)).longValue()); + Assert.assertEquals(2L, ((Number) GetItemScalarNode.executeUncached(storage, 2)).longValue()); + Assert.assertEquals(2L, ((Number) GetItemScalarNode.executeUncached(storage, 3)).longValue()); + Assert.assertEquals(3L, ((Number) GetItemScalarNode.executeUncached(storage, 4)).longValue()); } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/objects/ObjectHashMapTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/objects/ObjectHashMapTests.java index 18dcf485a3..d209b42c56 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/objects/ObjectHashMapTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/objects/ObjectHashMapTests.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * The Universal Permissive License (UPL), Version 1.0 @@ -74,9 +74,6 @@ import com.oracle.truffle.api.frame.Frame; import com.oracle.truffle.api.interop.TruffleObject; import com.oracle.truffle.api.nodes.Node; -import com.oracle.truffle.api.profiles.InlinedBranchProfile; -import com.oracle.truffle.api.profiles.InlinedConditionProfile; -import com.oracle.truffle.api.profiles.InlinedCountingConditionProfile; public class ObjectHashMapTests { public static final class DictKey implements TruffleObject { @@ -173,7 +170,7 @@ public void testLongHashMapStressTest() { // Basic tests of other methods Object[] oldKeys = keysToArray(map); - ObjectHashMap copy = map.copy(); + ObjectHashMap copy = copyMap(map); assertEquals(map.size(), copy.size()); for (Object key : oldKeys) { assertEquals(key.toString(), // @@ -220,8 +217,7 @@ private static void popValues(ObjectHashMap map, LinkedHashMap exp var keys = expected.keySet().stream().toList().reversed().stream().limit(count).toArray(Long[]::new); for (int i = 0; i < keys.length; i++) { Long key = keys[i]; - Object[] popped = PopNode.doPopWithRestart(null, map, InlinedConditionProfile.getUncached(), InlinedCountingConditionProfile.getUncached(), InlinedCountingConditionProfile.getUncached(), - InlinedBranchProfile.getUncached()); + Object[] popped = PopNode.doPopWithRestartForTests(map); Assert.assertEquals(Integer.toString(i), key, popped[0]); Assert.assertEquals(Integer.toString(i), expected.get(key), popped[1]); expected.remove(key); @@ -315,7 +311,7 @@ static void assertEqual(String message, LinkedHashMap expected, O Collections.reverse(keysValuesReversed); assertArrayEquals(message, keysValuesReversed.toArray(), reverseKeysToArray(actual)); - EconomicMapStorage storage = new EconomicMapStorage(actual, false); + EconomicMapStorage storage = toEconomicMapStorage(actual); int[] size = new int[]{0}; HashingStorageForEach.executeUncached(storage, new HashingStorageForEachCallback<>() { @Override @@ -330,12 +326,12 @@ public Object execute(Frame frame, Node inliningTarget, HashingStorage s, Hashin } private static Object[] keysToArray(ObjectHashMap m) { - EconomicMapStorage s = new EconomicMapStorage(m, false); + EconomicMapStorage s = toEconomicMapStorage(m); return iteratorToArray(s, HashingStorageGetIterator.executeUncached(s)); } private static Object[] reverseKeysToArray(ObjectHashMap m) { - EconomicMapStorage s = new EconomicMapStorage(m, false); + EconomicMapStorage s = toEconomicMapStorage(m); return iteratorToArray(s, HashingStorageGetReverseIterator.executeUncached(s)); } @@ -349,6 +345,24 @@ private static Object[] iteratorToArray(HashingStorage s, HashingStorageIterator private static int valueCounter = 0; + private static ObjectHashMap copyMap(ObjectHashMap original) { + EconomicMapStorage copy = EconomicMapStorage.create(original.size()); + MapCursor cursor = original.getEntries(); + while (cursor.advance()) { + put(copy, cursor.getKey().getValue(), cursor.getKey().getPythonHash(), cursor.getValue()); + } + return copy; + } + + private static EconomicMapStorage toEconomicMapStorage(ObjectHashMap map) { + EconomicMapStorage storage = EconomicMapStorage.create(map.size()); + MapCursor cursor = map.getEntries(); + while (cursor.advance()) { + put(storage, cursor.getKey().getValue(), cursor.getKey().getPythonHash(), cursor.getValue()); + } + return storage; + } + public static Object newValue() { return "Val: " + (valueCounter++); } @@ -358,25 +372,14 @@ private static long getKeyHash(Object key) { } private static Object get(ObjectHashMap map, Object key, long hash) { - InlinedCountingConditionProfile uncachedCounting = InlinedCountingConditionProfile.getUncached(); - return ObjectHashMap.GetNode.doGetWithRestart(null, null, map, key, hash, - InlinedBranchProfile.getUncached(), uncachedCounting, uncachedCounting, uncachedCounting, - uncachedCounting, uncachedCounting, - new EqNodeStub()); + return ObjectHashMap.GetNode.doGetWithRestartForTests(map, key, hash, new EqNodeStub()); } private static void remove(ObjectHashMap map, Object key, long hash) { - InlinedCountingConditionProfile uncachedCounting = InlinedCountingConditionProfile.getUncached(); - ObjectHashMap.RemoveNode.doRemoveWithRestart(null, null, map, key, hash, - InlinedBranchProfile.getUncached(), uncachedCounting, uncachedCounting, uncachedCounting, - uncachedCounting, InlinedBranchProfile.getUncached(), new EqNodeStub()); + ObjectHashMap.RemoveNode.doRemoveWithRestartForTests(map, key, hash, new EqNodeStub()); } private static void put(ObjectHashMap map, Object key, long hash, Object value) { - InlinedCountingConditionProfile uncachedCounting = InlinedCountingConditionProfile.getUncached(); - PutNode.doPutWithRestart(null, null, map, key, hash, value, - InlinedBranchProfile.getUncached(), uncachedCounting, uncachedCounting, uncachedCounting, - uncachedCounting, InlinedBranchProfile.getUncached(), InlinedBranchProfile.getUncached(), - new EqNodeStub()); + PutNode.doPutWithRestartForTests(map, key, hash, value, new EqNodeStub()); } } diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/ParseWithArgumentsInstrumentTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/ParseWithArgumentsInstrumentTests.java new file mode 100644 index 0000000000..9646117a32 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/ParseWithArgumentsInstrumentTests.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.runtime; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; +import java.util.function.Function; + +import org.graalvm.polyglot.Context; +import org.graalvm.polyglot.Engine; +import org.graalvm.polyglot.Instrument; +import org.junit.Test; + +import com.oracle.truffle.api.ContextLocal; +import com.oracle.truffle.api.TruffleContext; +import com.oracle.truffle.api.instrumentation.ContextsListener; +import com.oracle.truffle.api.instrumentation.TruffleInstrument; +import com.oracle.truffle.api.nodes.LanguageInfo; + +public class ParseWithArgumentsInstrumentTests { + private static final String TEST_INSTRUMENT_ID = "parse-with-arguments-instrument-tests"; + + @SuppressWarnings("unchecked") + @Test + public void instrumentParseWithArgumentsDuringLanguageContextInitializationExecutes() { + try (Engine engine = Engine.create()) { + Instrument instrument = engine.getInstruments().get(TEST_INSTRUMENT_ID); + Function registrar = instrument.lookup(Function.class); + registrar.apply(org.graalvm.polyglot.Source.create("python", "x + 1")); + try (Context context = Context.newBuilder("python").engine(engine).allowExperimentalOptions(true).allowAllAccess(true).build()) { + assertEquals(42, context.eval("python", "42").asInt()); + } + } + } + + @TruffleInstrument.Registration(id = TEST_INSTRUMENT_ID, services = Function.class) + public static final class ParseWithArgumentsInitializationInstrument extends TruffleInstrument { + private final ContextLocal parsed = locals.createContextLocal((ctx) -> new boolean[1]); + + @Override + protected void onCreate(Env env) { + Function registerSource = (polyglotSource) -> { + com.oracle.truffle.api.source.Source source = com.oracle.truffle.api.source.Source.newBuilder( + polyglotSource.getLanguage(), polyglotSource.getCharacters(), polyglotSource.getName()).build(); + env.getInstrumenter().attachContextsListener(new ContextsListener() { + @Override + public void onContextCreated(TruffleContext context) { + } + + @Override + public void onLanguageContextCreate(TruffleContext context, LanguageInfo language) { + } + + @Override + public void onLanguageContextCreated(TruffleContext context, LanguageInfo language) { + } + + @Override + public void onLanguageContextInitialize(TruffleContext context, LanguageInfo language) { + } + + @Override + public void onLanguageContextInitialized(TruffleContext context, LanguageInfo language) { + if (!"python".equals(language.getId())) { + return; + } + boolean[] seen = parsed.get(context); + if (seen[0]) { + return; + } + seen[0] = true; + try { + env.parse(source, "x").call(41); + } catch (IOException e) { + throw new AssertionError(e); + } + } + + @Override + public void onLanguageContextFinalized(TruffleContext context, LanguageInfo language) { + } + + @Override + public void onLanguageContextDisposed(TruffleContext context, LanguageInfo language) { + } + + @Override + public void onContextClosed(TruffleContext context) { + } + }, true); + return null; + }; + env.registerService(registerSource); + } + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextEntropyTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextEntropyTests.java new file mode 100644 index 0000000000..7dcee55008 --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextEntropyTests.java @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.runtime; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Map; +import java.util.Random; + +import org.graalvm.polyglot.PolyglotException; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.Assume; + +import com.oracle.graal.python.runtime.PythonContext; +import com.oracle.graal.python.test.PythonTests; + +public class PythonContextEntropyTests { + + @Before + public void checkLinuxOnly() { + Assume.assumeTrue(System.getProperty("os.name").toLowerCase().contains("linux")); + } + + @After + public void tearDown() { + PythonTests.closeContext(); + } + + @Test + public void fixedInitializationEntropySourceSeedsHashSecretDeterministically() { + long seed = 0x1234ABCDL; + PythonTests.enterContext(Map.of("python.InitializationEntropySource", "fixed:0x1234ABCD"), new String[0]); + PythonContext context = PythonContext.get(null); + + byte[] expected = new byte[24]; + new Random(seed).nextBytes(expected); + + assertArrayEquals(expected, context.getHashSecret()); + } + + @Test + public void deviceInitializationEntropySourceSeedsHashSecretFromConfiguredPath() throws IOException { + byte[] expected = new byte[24]; + for (int i = 0; i < expected.length; i++) { + expected[i] = (byte) (i + 1); + } + byte[] source = new byte[expected.length + 8]; + System.arraycopy(expected, 0, source, 0, expected.length); + for (int i = expected.length; i < source.length; i++) { + source[i] = (byte) 0xFF; + } + Path tempFile = Files.createTempFile("graalpy-init-entropy-", ".bin"); + Files.write(tempFile, source); + + try { + PythonTests.enterContext(Map.of("python.InitializationEntropySource", "device:" + tempFile), new String[0]); + PythonContext context = PythonContext.get(null); + assertArrayEquals(expected, context.getHashSecret()); + } finally { + Files.deleteIfExists(tempFile); + } + } + + @Test + public void deviceInitializationEntropySourceThrowsProviderExceptionWhenExhausted() throws IOException { + Path tempFile = Files.createTempFile("graalpy-init-entropy-short-", ".bin"); + Files.write(tempFile, new byte[]{1, 2, 3, 4}); + + try { + try { + PythonTests.enterContext(Map.of("python.InitializationEntropySource", "device:" + tempFile), new String[0]); + fail("expected PolyglotException"); + } catch (PolyglotException e) { + assertTrue(e.getMessage().contains("ProviderException")); + assertTrue(e.getMessage().contains("initialization entropy device exhausted")); + } + } finally { + Files.deleteIfExists(tempFile); + } + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextPathTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextPathTests.java new file mode 100644 index 0000000000..39ac84456f --- /dev/null +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonContextPathTests.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * The Universal Permissive License (UPL), Version 1.0 + * + * Subject to the condition set forth below, permission is hereby granted to any + * person obtaining a copy of this software, associated documentation and/or + * data (collectively the "Software"), free of charge and under any and all + * copyright rights in the Software, and any and all patent rights owned or + * freely licensable by each licensor hereunder covering either (i) the + * unmodified Software as contributed to or provided by such licensor, or (ii) + * the Larger Works (as defined below), to deal in both + * + * (a) the Software, and + * + * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if + * one is included with the Software each a "Larger Work" to which the Software + * is contributed by such licensors), + * + * without restriction, including without limitation the rights to copy, create + * derivative works of, display, perform, and distribute the Software and make, + * use, sell, offer for sale, import, export, have made, and have sold the + * Software and the Larger Work(s), and to sublicense the foregoing rights on + * either these or other terms. + * + * This license is subject to the following condition: + * + * The above copyright notice and either this complete permission notice or at a + * minimum a reference to the UPL must be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.oracle.graal.python.test.runtime; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeFalse; + +import org.junit.After; +import org.junit.Test; + +import com.oracle.graal.python.runtime.PythonContext; +import com.oracle.graal.python.test.PythonTests; +import com.oracle.truffle.api.TruffleFile; + +public class PythonContextPathTests { + + @After + public void tearDown() { + PythonTests.closeContext(); + } + + @Test + public void isPyFileInLanguageHomeNormalizesPathBeforeContainmentCheck() { + PythonTests.enterContext(); + PythonContext context = PythonContext.get(null); + String languageHomePath = context.getLanguageHome().toJavaStringUncached(); + TruffleFile languageHome = context.getEnv().getInternalTruffleFile(languageHomePath).getAbsoluteFile().normalize(); + assumeFalse("resource-backed language home is rooted at /", "/".equals(languageHome.getPath())); + TruffleFile insideLanguageHome = context.getEnv().getInternalTruffleFile(languageHomePath + "/lib-python"); + TruffleFile escapedLanguageHome = context.getEnv().getInternalTruffleFile(languageHomePath + "/../outside.py"); + + assertTrue(context.isPyFileInLanguageHome(insideLanguageHome)); + assertFalse("escaped path " + escapedLanguageHome.getAbsoluteFile().normalize() + + " should not be contained in language home " + languageHome, + context.isPyFileInLanguageHome(escapedLanguageHome)); + } +} diff --git a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonModuleTests.java b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonModuleTests.java index ead733eca1..2ff8b9925f 100644 --- a/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonModuleTests.java +++ b/graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/PythonModuleTests.java @@ -92,7 +92,7 @@ public void tearDown() { @Test public void pythonModuleTest() { - PythonModule module = PFactory.createPythonModule(context.getLanguage(), tsLiteral("testModule")); + PythonModule module = PFactory.createPythonModule(tsLiteral("testModule")); assertEquals("testModule", module.getAttribute(T___NAME__).toString()); assertEquals("None", module.getAttribute(T___DOC__).toString()); assertEquals("None", module.getAttribute(T___PACKAGE__).toString()); diff --git a/graalpython/com.oracle.graal.python.test/src/runner.py b/graalpython/com.oracle.graal.python.test/src/runner.py index cd2589299c..8725692a1c 100644 --- a/graalpython/com.oracle.graal.python.test/src/runner.py +++ b/graalpython/com.oracle.graal.python.test/src/runner.py @@ -1,4 +1,4 @@ -# Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # The Universal Permissive License (UPL), Version 1.0 @@ -41,7 +41,6 @@ import enum import fnmatch import json -import math import os import pickle import platform @@ -60,6 +59,7 @@ import typing import unittest import unittest.loader +import urllib.request from abc import abstractmethod from collections import defaultdict from dataclasses import dataclass, field @@ -81,6 +81,25 @@ CURRENT_PLATFORM = f'{sys.platform}-{platform.machine()}' CURRENT_PLATFORM_KEYS = frozenset({CURRENT_PLATFORM}) +RUNNER_ENV = {} +DISABLE_JIT_ENV = {'GRAAL_PYTHON_VM_ARGS': '--experimental-options --engine.Compilation=false'} +# The worker transport sends pickled data, so keep it on loopback only. +WORKER_SERVER_HOST = '127.0.0.1' + +GITHUB_CI = os.environ.get("GITHUB_CI", None) +if GITHUB_CI: + PLATFORM_KEYS.add("github") + CURRENT_PLATFORM += "-github" + +# We leave the JIT enabled for the tests themselves, but disable it for subprocesses +# noinspection PyUnresolvedReferences +if IS_GRAALPY and __graalpython__.is_native and 'GRAAL_PYTHON_VM_ARGS' not in os.environ: + try: + subprocess.check_output([sys.executable, '--version'], env={**os.environ, **DISABLE_JIT_ENV}) + RUNNER_ENV = DISABLE_JIT_ENV + except subprocess.CalledProcessError: + pass + class Logger: report_incomplete = sys.stdout.isatty() @@ -212,7 +231,7 @@ def out_tell(): T = typing.TypeVar('T') -def partition_list(l: list[T], fn: typing.Callable[[T], bool]): +def partition_list(l: list[T], fn: typing.Callable[[T], bool]) -> tuple[list[T], list[T]]: a = [] b = [] for item in l: @@ -250,6 +269,17 @@ def addFailure(self, test, err): super().addFailure(test, err) self.report_result(self.make_result(test, status=TestStatus.FAILURE, param=format_exception(err[1]))) + def addSubTest(self, test, subtest, err): + super().addSubTest(test, subtest, err) + + if err: + if issubclass(err[0], test.failureException): + status = TestStatus.FAILURE + else: + status = TestStatus.ERROR + + self.report_result(self.make_result(test, status=status, param=format_exception(err[1]))) + def addError(self, test, err): super().addError(test, err) self.report_result(self.make_result(test, status=TestStatus.ERROR, param=format_exception(err[1]))) @@ -335,16 +365,16 @@ def __init__(self, *, failfast: bool, report_durations: int | None): self.total_duration = 0.0 @staticmethod - def report_start(test_id: TestId): - log(f"{test_id} ... ", incomplete=True) + def report_start(test_id: TestId, prefix=''): + log(f"{prefix}{test_id} ... ", incomplete=True) - def report_result(self, result: TestResult): + def report_result(self, result: TestResult, prefix=''): self.results.append(result) message = f"{result.test_id} ... {result.status}" if result.status == TestStatus.SKIPPED and result.param: - message = f"{message} {result.param!r}" + message = f"{prefix}{message} {result.param!r}" else: - message = f"{message} ({result.duration:.2f}s)" + message = f"{prefix}{message} ({result.duration:.2f}s)" log(message) def tests_failed(self): @@ -423,6 +453,14 @@ def run_tests(self, tests: list['TestSuite']): self.display_summary() def generate_mx_report(self, path: str): + # Some reports may be split when ran on github, this sets different file names + report_suffix = os.environ.get("MX_REPORT_SUFFIX") + if report_suffix: + if os.environ.get("GITHUB_CI"): + report_suffix = f"{report_suffix}_{CURRENT_PLATFORM}" + tmppath, ext = os.path.splitext(path) + path = f"{tmppath}{report_suffix}{ext}" + report_data = [] for result in self.results: # Skip synthetic results for failed class setups and such @@ -463,7 +501,7 @@ def generate_tags(self, append=False): def update_tags(test_file: 'TestFile', results: list[TestResult], tag_platform: str, untag_failed=False, untag_skipped=False, untag_missing=False): current = read_tags(test_file, allow_exclusions=True) - exclusions, current = partition_list(current, lambda t: isinstance(t, TagExclusion)) + exclusions, current = partition_list(current, lambda t: t.is_exclusion) status_by_id = {r.test_id.normalized(): r.status for r in results} tag_by_id = {} for tag in current: @@ -487,7 +525,15 @@ def update_tags(test_file: 'TestFile', results: list[TestResult], tag_platform: tag_by_id[test_id] = Tag.for_key(test_id, tag_platform) for exclusion in exclusions: - tag_by_id.pop(exclusion.test_id, None) + if tag := tag_by_id.get(exclusion.test_id): + if exclusion.keys: + tag = tag.without_keys(exclusion.keys) + else: + tag = None + if not tag: + del tag_by_id[exclusion.test_id] + else: + tag_by_id[exclusion.test_id] = tag tags = set(tag_by_id.values()) | set(exclusions) write_tags(test_file, tags) @@ -502,7 +548,7 @@ def write_tags(test_file: 'TestFile', tags: typing.Iterable['Tag']): tag_file.unlink(missing_ok=True) return with open(tag_file, 'w') as f: - for tag in sorted(tags, key=lambda t: t.test_id.test_name): + for tag in sorted(tags, key=lambda t: (t.test_id.test_name, t.is_exclusion)): f.write(f'{tag}\n') @@ -532,10 +578,10 @@ def __init__(self, *, num_processes, subprocess_args, separate_workers, timeout_ self.crashes = [] self.default_test_timeout = 600 - def report_result(self, result: TestResult): + def report_result(self, result: TestResult, prefix=''): if self.failfast and result.status in FAILED_STATES: self.stop_event.set() - super().report_result(result) + super().report_result(result, prefix=prefix) def tests_failed(self): return super().tests_failed() or bool(self.crashes) @@ -550,10 +596,36 @@ def partition_tests_into_processes(self, suites: list['TestSuite']) -> list[list lambda suite: suite.test_file.config.new_worker_per_file, ) partitions = [suite.collected_tests for suite in per_file_suites] - per_partition = int(math.ceil(len(unpartitioned) / max(1, self.num_processes))) - while unpartitioned: - partitions.append([test for suite in unpartitioned[:per_partition] for test in suite.collected_tests]) - unpartitioned = unpartitioned[per_partition:] + + # Use timings if available to partition unpartitioned optimally + timings = {} + if unpartitioned and self.num_processes: + configdir = unpartitioned[0].test_file.config.configdir if unpartitioned else None + if configdir: + timing_path = configdir / f"timings-{sys.platform.lower()}.json" + if timing_path.exists(): + with open(timing_path, "r", encoding="utf-8") as f: + timings = json.load(f) + + timed_files = [] + for suite in unpartitioned: + file_path = str(suite.test_file.path).replace("\\", "/") + total = timings.get(file_path, 20.0) + timed_files.append((total, suite)) + + # Sort descending by expected time + timed_files.sort(reverse=True, key=lambda x: x[0]) + + # Greedily assign to balance by timing sum + process_loads = [[] for _ in range(self.num_processes)] + process_times = [0.0] * self.num_processes + for t, suite in timed_files: + i = process_times.index(min(process_times)) + process_loads[i].append(suite) + process_times[i] += t + for group in process_loads: + partitions.append([test for suite in group for test in suite.collected_tests]) + return partitions def run_tests(self, tests: list['TestSuite']): @@ -582,7 +654,7 @@ def run_tests(self, tests: list['TestSuite']): log(crash) def run_partitions_in_subprocesses(self, executor, partitions: list[list['Test']]): - workers = [SubprocessWorker(self, partition) for i, partition in enumerate(partitions)] + workers = [SubprocessWorker(i, self, partition) for i, partition in enumerate(partitions)] futures = [executor.submit(worker.run_in_subprocess_and_watch) for worker in workers] def dump_worker_status(): @@ -626,7 +698,8 @@ def sigterm_handler(_signum, _frame): class SubprocessWorker: - def __init__(self, runner: ParallelTestRunner, tests: list['Test']): + def __init__(self, worker_id: int, runner: ParallelTestRunner, tests: list['Test']): + self.prefix = f'[worker-{worker_id + 1}] ' self.runner = runner self.stop_event = runner.stop_event self.lock = threading.RLock() @@ -649,7 +722,7 @@ def process_event(self, event): except ValueError: # It executed something we didn't ask for. Not sure why this happens log(f'WARNING: unexpected test started {test_id}') - self.runner.report_start(test_id) + self.runner.report_start(test_id, prefix=self.prefix) with self.lock: self.last_started_test_id = test_id self.last_started_time = time.time() @@ -668,7 +741,7 @@ def process_event(self, event): output=test_output, duration=event.get('duration'), ) - self.runner.report_result(result) + self.runner.report_result(result, prefix=self.prefix) with self.lock: self.last_started_test_id = None self.last_started_time = time.time() # Starts timeout for the following teardown/setup @@ -720,7 +793,7 @@ def run_in_subprocess_and_watch(self): self.thread = threading.current_thread() with ( tempfile.TemporaryDirectory(prefix='graalpytest-') as tmp_dir, - socket.create_server(('0.0.0.0', 0)) as server, + socket.create_server((WORKER_SERVER_HOST, 0)) as server, ): tmp_dir = Path(tmp_dir) @@ -820,7 +893,7 @@ def run_in_subprocess_and_watch(self): param=message, output=output, duration=(time.time() - self.last_started_time), - )) + ), prefix=self.prefix) if blame_id is not self.last_started_test_id: # If we're here, it means we didn't know exactly which test we were executing, we were # somewhere in between @@ -839,7 +912,13 @@ def run_in_subprocess_and_watch(self): def platform_keys_match(items: typing.Iterable[str]): - return any(all(key in PLATFORM_KEYS for key in item.split('-')) for item in items) + matches = [] + for item in items: + if GITHUB_CI: + if not "github" in item.split('-'): + continue + matches.append(all(key in PLATFORM_KEYS for key in item.split('-'))) + return any(matches) @dataclass @@ -898,11 +977,6 @@ def parse_config(cls, config_path: Path): tags_dir = None if config_tags_dir := settings.get('tags_dir'): tags_dir = (config_path.parent / config_tags_dir).resolve() - # Temporary hack for Bytecode DSL development in master branch: - if IS_GRAALPY and __graalpython__.is_bytecode_dsl_interpreter and tags_dir: - new_tags_dir = (config_path.parent / (config_tags_dir + '_bytecode_dsl')).resolve() - if new_tags_dir.exists(): - tags_dir = new_tags_dir return cls( configdir=config_path.parent.resolve(), rootdir=config_path.parent.parent.resolve(), @@ -972,6 +1046,7 @@ class TestSuite: collected_tests: list['Test'] def run(self, result): + os.environ.update(RUNNER_ENV) saved_path = sys.path[:] sys.path[:] = self.pythonpath try: @@ -1139,31 +1214,31 @@ def collect(all_specifiers: list[TestSpecifier], *, use_tags=False, ignore=None, class Tag: test_id: TestId keys: frozenset[str] + is_exclusion: bool + comment: str | None = False @classmethod - def for_key(cls, test_id, key): - return Tag(test_id, frozenset({key})) - - def with_key(self, key: str): - return Tag(self.test_id, self.keys | {key}) + def for_key(cls, test_id, key) -> 'Tag': + return Tag(test_id, frozenset({key}), is_exclusion=False) - def without_key(self, key: str): - if key not in self.keys: - return self - keys = self.keys - {key} - if keys: - return Tag(self.test_id, keys) - - def __str__(self): - return f'{self.test_id.test_name} @ {",".join(sorted(self.keys))}' + def with_key(self, key: str) -> 'Tag': + return Tag(self.test_id, self.keys | {key}, is_exclusion=self.is_exclusion) + def without_key(self, key: str) -> 'Tag | None': + return self.without_keys({key}) -@dataclass(frozen=True) -class TagExclusion(Tag): - comment: str | None + def without_keys(self, keys: set[str]) -> 'Tag | None': + keys = self.keys - keys + if keys: + if keys == self.keys: + return self + return Tag(self.test_id, keys, is_exclusion=self.is_exclusion) def __str__(self): - s = f'!{self.test_id.test_name}' + s = '' + if self.is_exclusion: + s += '!' + s += self.test_id.test_name if self.keys: s += f' @ {",".join(sorted(self.keys))}' if self.comment: @@ -1189,21 +1264,22 @@ def read_tags(test_file: TestFile, allow_exclusions=False) -> list[Tag]: test, _, keys = line.partition('@') test = test.strip() keys = keys.strip() + is_exclusion = False if test.startswith('!'): - if allow_exclusions: - test = test.removeprefix('!') - tags.append(TagExclusion( - TestId(test_path, test), - frozenset(keys.split(',')) if keys else frozenset(), - comment, - )) - else: - if not keys: - log(f'WARNING: invalid tag {test}: missing platform keys') - tags.append(Tag( - TestId(test_path, test), - frozenset(keys.split(',')), - )) + is_exclusion = True + test = test.removeprefix('!') + + if not keys and not is_exclusion: + log(f'WARNING: invalid tag {test}: missing platform keys') + + tag = Tag( + TestId(test_path, test), + frozenset(keys.split(',')) if keys else frozenset(keys), + is_exclusion=is_exclusion, + comment=comment, + ) + if not is_exclusion or allow_exclusions: + tags.append(tag) comment = None return tags @@ -1236,7 +1312,7 @@ def _recv(self, size): while len(data) < size: read = self.socket.recv(size - len(data)) if not read: - return data + raise ConnectionClosed data += read return data @@ -1253,7 +1329,7 @@ def poll(self, timeout=None): def main_worker(args): - with socket.create_connection(('localhost', args.port)) as sock: + with socket.create_connection((WORKER_SERVER_HOST, args.port)) as sock: conn = Connection(sock) tests = conn.recv() @@ -1264,7 +1340,14 @@ def main_worker(args): test_suite.run(result) -def main_merge_tags(args): +def main_merge_tags(args, parser): + if len(args.pos) == 1: + args.report_path = args.pos[0] + elif len(args.pos) == 2: + args.platform, args.report_path = args.pos + else: + parser.error("wrong number of arguments") + with open(args.report_path) as f: report = json.load(f) status_map = { @@ -1299,6 +1382,31 @@ def get_bool_env(name: str): return os.environ.get(name, '').lower() in ('true', '1') +def main_extract_test_timings(args): + """ + Fetches a test log from the given URL, extracts per-file test timings, and writes the output as JSON. + """ + + # Download the log file + with urllib.request.urlopen(args.url) as response: + log_content = response.read().decode("utf-8", errors="replace") + + pattern = re.compile( + r"^(?P[^\s:]+)::\S+ +\.\.\. (?:ok|FAIL|ERROR|SKIPPED|expected failure|unexpected success|\S+) \((?P