hexsha stringlengths 40 40 | size int64 1 1.03M | ext stringclasses 10 values | lang stringclasses 1 value | max_stars_repo_path stringlengths 3 239 | max_stars_repo_name stringlengths 5 130 | max_stars_repo_head_hexsha stringlengths 40 78 | max_stars_repo_licenses listlengths 1 10 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 3 239 | max_issues_repo_name stringlengths 5 130 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 10 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 239 | max_forks_repo_name stringlengths 5 130 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 10 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 1 1.03M | avg_line_length float64 1 958k | max_line_length int64 1 1.03M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ace01bcd8b665b753c9a360f79f2666e6f12a10a | 1,717 | py | Python | test/nba/test_playerid.py | jgershen/sportsball | 8aa2a599091fb14d1897f2e4b77384e9ee6b0eed | [
"MIT"
] | 21 | 2016-03-12T00:59:04.000Z | 2022-03-01T21:32:51.000Z | test/nba/test_playerid.py | jgershen/sportsball | 8aa2a599091fb14d1897f2e4b77384e9ee6b0eed | [
"MIT"
] | 1 | 2017-04-17T04:39:46.000Z | 2017-04-17T04:39:46.000Z | test/nba/test_playerid.py | jgershen/sportsball | 8aa2a599091fb14d1897f2e4b77384e9ee6b0eed | [
"MIT"
] | 4 | 2016-07-25T11:55:52.000Z | 2019-06-19T20:55:53.000Z | from dfs.nba.playerid import name2nbaid, team_tla, get_position
def test_name2nbaid():
# TODO: test using team lookup here as well?
good_matches = [("Ed Davis", "davised01"),
("Nick Collison", "collini01"),
("Serge Ibaka", "ibakase01"),
("Tony Snell", "snellto01"),
("Nikola Mirotic", "mirotni01"),
("Maurice Harkless", "harklma01"),
("Nemanja Bjelica", "bjeline01"),
("Gordon Hayward", "haywago01"),
("Steven Adams", "adamsst01"),
("Pau Gasol", "gasolpa01"),
("Brian Roberts", "roberbr01"),
("Andre Miller", "millean02"),
("Elijah Millsap", "millsel01"),
("Anthony Morrow", "morroan01"),
("Ricky Rubio", "rubiori01"),
("Hassan Whiteside", "whiteha01"),
("Kevin Durant", "duranke01"),
("Bryce Cotton", "cottobr01"),
("Dirk Nowitzki", "nowitdi01"),
("Trey Lyles", "lylestr01")]
for name, match in good_matches:
assert name2nbaid(name) == match
def test_team_lookup():
assert team_tla("LA Lakers") == "LAL"
assert team_tla("Phoenix Suns") == "PHO"
assert team_tla("BRK") == "BRK"
assert team_tla("CLV") == "CLE"
assert team_tla("gsw") == "GSW"
assert team_tla("NOH") == "NOP"
assert team_tla("SAC") == "SAS"
def test_player_position():
assert 'SF' == get_position('jamesle01')
assert 'PG' == get_position('curryst01')
assert 'C' == get_position('duncati01')
assert 'PF' == get_position('couside01')
assert 'SG' == get_position('hardeja01') | 39.930233 | 63 | 0.533489 |
ace01c3019dfeec5b919ac0eaf75bd0168689381 | 9,475 | py | Python | smartdns/server.py | duanhongyi/smartdns | 164e86a5bdbca734edae91a89ef4b51ae3e27653 | [
"BSD-2-Clause"
] | 13 | 2019-09-10T07:41:09.000Z | 2021-09-24T23:52:24.000Z | smartdns/server.py | duanhongyi/smartdns | 164e86a5bdbca734edae91a89ef4b51ae3e27653 | [
"BSD-2-Clause"
] | 2 | 2020-09-23T14:08:25.000Z | 2021-11-15T07:16:57.000Z | smartdns/server.py | duanhongyi/smartdns | 164e86a5bdbca734edae91a89ef4b51ae3e27653 | [
"BSD-2-Clause"
] | 5 | 2020-09-27T01:11:14.000Z | 2021-03-26T06:11:51.000Z | # -*- coding: utf-8 -*-
import logging
import random
import re
import time
from twisted.internet import defer
from twisted.names import dns, server, client, common, resolve
from twisted.python import failure
from . import sdns
logger = logging.getLogger(__name__)
typeToMethod = {
dns.A: 'lookupAddress',
dns.AAAA: 'lookupIPV6Address',
dns.A6: 'lookupAddress6',
dns.NS: 'lookupNameservers',
dns.CNAME: 'lookupCanonicalName',
dns.SOA: 'lookupAuthority',
dns.MB: 'lookupMailBox',
dns.MG: 'lookupMailGroup',
dns.MR: 'lookupMailRename',
dns.NULL: 'lookupNull',
dns.WKS: 'lookupWellKnownServices',
dns.PTR: 'lookupPointer',
dns.HINFO: 'lookupHostInfo',
dns.MINFO: 'lookupMailboxInfo',
dns.MX: 'lookupMailExchange',
dns.TXT: 'lookupText',
dns.SPF: 'lookupSenderPolicy',
dns.RP: 'lookupResponsibility',
dns.AFSDB: 'lookupAFSDatabase',
dns.SRV: 'lookupService',
dns.NAPTR: 'lookupNamingAuthorityPointer',
dns.AXFR: 'lookupZone',
dns.ALL_RECORDS: 'lookupAllRecords',
}
smartType = ('lookupAddress', 'lookupAuthority')
class FailureHandler:
def __init__(self, resolver, query, timeout, addr=None, edns=None):
self.resolver = resolver
self.query = query
self.timeout = timeout
self.addr = addr
self.edns = edns
def __call__(self, failure):
# AuthoritativeDomainErrors should halt resolution attempts
failure.trap(dns.DomainError, defer.TimeoutError, NotImplementedError)
return self.resolver(self.query, self.timeout, self.addr, self.edns)
class MapResolver(client.Resolver):
def __init__(self, finder, a_mapping, ns_mapping, soa_mapping, servers):
self.cache = {}
self.finder = finder
self.a_mapping = a_mapping
self.ns_mapping = ns_mapping
self.soa_mapping = soa_mapping
client.Resolver.__init__(self, servers=servers)
def _lookup(self, name, cls, type, timeout):
q = dns.Query(name, type, cls)
def set_result(result):
ttl = result[0][0].ttl
self.cache[q] = (result, time.time() + ttl)
return result
def get_result(q):
if q in self.cache:
result, expire = self.cache[q]
if expire < time.time():
client.Resolver._lookup(
self, name, cls, type, timeout).addCallback(set_result)
return result
else:
return client.Resolver._lookup(
self, name, cls, type, timeout).addCallback(set_result)
return get_result(q)
def query(self, query, timeout=None, addr=None, edns=None):
try:
if typeToMethod[query.type] in smartType:
return self.typeToMethod[query.type](str(query.name), timeout, addr, edns)
else:
return self.typeToMethod[query.type](str(query.name), timeout)
except KeyError as e:
return defer.fail(failure.Failure(NotImplementedError(str(self.__class__) + " " + str(query.type))))
def lookupAddress(self, name, timeout=None, addr=None, edns=None):
def packResult(value, ttl):
ret = []
add = []
for x in value:
ret.append(dns.RRHeader(name, dns.A, dns.IN, ttl, dns.Record_A(x, ttl), True))
if edns is not None:
if edns.rdlength > 8:
add.append(dns.RRHeader('', sdns.EDNS, 4096, edns.ttl, edns.payload, True))
else:
add.append(dns.RRHeader('', sdns.EDNS, 4096, 0, sdns.Record_EDNS(None, 0), True))
return [ret, (), add]
wildcard = name[name.index("."):] if "." in name else None
if name in self.a_mapping:
ttl = self.a_mapping[name]['ttl']
result = self.finder.findIP(str(addr[0]), name)
random.shuffle(result) # 返回的IP数组乱序
return packResult(result, ttl)
elif wildcard is not None and wildcard in self.a_mapping:
ttl = self.a_mapping[wildcard]['ttl']
result = self.finder.findIP(str(addr[0]), wildcard)
random.shuffle(result) # 返回的IP数组乱序
return packResult(result, ttl)
else:
return self._lookup(name, dns.IN, dns.A, timeout)
def lookupNameservers(self, name, timeout=None):
if name in self.ns_mapping:
result = self.ns_mapping[name]
ttl = result['ttl']
record = re.split(r',|\s+', result['record'])
def packResultNS(value):
ret = []
for x in value:
ret.append(dns.RRHeader(name, dns.NS, dns.IN, ttl, dns.Record_NS(x, ttl), True))
return [ret, (), ()]
return packResultNS(record)
else:
return self._lookup(name, dns.IN, dns.NS, timeout)
def lookupAuthority(self, name, timeout=None, addr=None, edns=None):
if name in self.soa_mapping:
result = self.soa_mapping[name]
add = []
def packResultSOA(value):
if edns is not None:
if edns.rdlength > 8:
add.append(dns.RRHeader('', dns.EDNS, 4096, edns.ttl, edns.payload, True))
else:
add.append(dns.RRHeader('', dns.EDNS, 4096, 0, sdns.Record_EDNS(None, 0), True))
return [(dns.RRHeader(name, dns.SOA, dns.IN, value['ttl'],
dns.Record_SOA(value['record'], value['email'], value['serial'], value['refresh'],
value['retry'], value['expire'], value['ttl']), True),),
(),
add
]
ret = packResultSOA(result)
logger.info("SOA\t[domain: %s]\t[return: %s]\t[additional: %s]" % \
(name, result, add))
return ret
else:
return self._lookup(name, dns.IN, dns.SOA, timeout)
def lookupIPV6Address(self, name, timeout=None, addr=None):
return [(), (), ()]
class SmartResolverChain(resolve.ResolverChain):
def __init__(self, resolvers):
# resolve.ResolverChain.__init__(self, resolvers)
common.ResolverBase.__init__(self)
self.resolvers = resolvers
def _lookup(self, name, cls, type, timeout, addr=None, edns=None):
q = dns.Query(name, type, cls)
d = defer.fail(failure.Failure(dns.DomainError(name)))
for r in self.resolvers:
d = d.addErrback(
FailureHandler(r.query, q, timeout, addr, edns)
)
return d
def _query(self, query, timeout=None, addr=None, edns=None):
if typeToMethod[query.type] in smartType:
return self.typeToMethod[query.type](str(query.name), timeout, addr, edns)
else:
return self.typeToMethod[query.type](str(query.name), timeout)
def query(self, query, timeout=None, addr=None, edns=None):
try:
return self._query(query, timeout, addr, edns)
except KeyError as e:
return defer.fail(failure.Failure(NotImplementedError(str(self.__class__) + " " + str(query.type))))
def lookupAddress(self, name, timeout=None, addr=None, edns=None):
return self._lookup(name, dns.IN, dns.A, timeout, addr, edns)
def lookupAuthority(self, name, timeout=None, addr=None, edns=None):
return self._lookup(name, dns.IN, dns.SOA, timeout, addr, edns)
def lookupIPV6Address(self, name, timeout=None, addr=None, edns=None):
return self._lookup(name, dns.IN, dns.AAAA, timeout, addr, edns)
def lookupNameservers(self, name, timeout=None, addr=None, edns=None):
return self._lookup(name, dns.IN, dns.NS, timeout, addr, edns)
class SmartDNSFactory(server.DNSServerFactory):
def handleQuery(self, message, protocol, address):
# if len(message.additional) > 0:
# print inspect.getmembers(message.additional[0]
# 可以支持多个query
query = message.queries[0]
edns = None
cliAddr = address
if query.type == 43 or typeToMethod[query.type] == 'lookupAllRecords':
return [(), (), ()]
if isinstance(protocol, dns.DNSProtocol):
cliAddr = protocol.transport.client
elif typeToMethod[query.type] in smartType and \
len(message.additional) != 0 and \
message.additional[0].type == 41 and \
message.additional[0].rdlength > 8:
if isinstance(message.additional[0].payload, dns.Record_A):
cliAddr = (message.additional[0].payload.dottedQuad(), 0)
edns = message.additional[0]
return self.resolver.query(query, addr=cliAddr, edns=edns).addCallback(
self.gotResolverResponse, protocol, message, address
).addErrback(
self.gotResolverError, protocol, message, address
)
def __init__(self, authorities=None, clients=None, verbose=0):
resolvers = []
if authorities is not None:
resolvers.extend(authorities)
if clients is not None:
resolvers.extend(clients)
self.canRecurse = not not clients
self.resolver = SmartResolverChain(resolvers)
self.verbose = verbose
self.connections = []
| 38.052209 | 120 | 0.58934 |
ace01cce1433eae8b50c26817f091ea505f6a83c | 9,264 | py | Python | build.py | Python3pkg/500lines | e9c05e45d6eedf36ceef67ec5f817a39a07980fb | [
"CC-BY-3.0"
] | 1 | 2021-03-21T13:12:07.000Z | 2021-03-21T13:12:07.000Z | build.py | Python3pkg/500lines | e9c05e45d6eedf36ceef67ec5f817a39a07980fb | [
"CC-BY-3.0"
] | null | null | null | build.py | Python3pkg/500lines | e9c05e45d6eedf36ceef67ec5f817a39a07980fb | [
"CC-BY-3.0"
] | null | null | null | #!/usr/bin/env python
import envoy
import glob
import os
def main(chapters=[], epub=False, pdf=False, html=False, mobi=False, pandoc_epub=False):
if not os.path.isdir('output'):
os.mkdir('output')
else:
output_files = glob.glob('output/*')
for f in output_files:
run('rm {}'.format(f))
chapter_dirs = [
'blockcode',
'ci',
'cluster',
'contingent',
'crawler',
'dagoba',
'data-store',
'event-web-framework',
'flow-shop',
'functionalDB',
'image-filters',
'interpreter',
'modeller',
'objmodel',
'ocr',
'pedometer',
'same-origin-policy',
'sampler',
'spreadsheet',
'static-analysis',
'template-engine',
'web-server',
]
if len(chapters) > 0:
chapter_dirs = [
chapter_dir
for chapter_dir in
chapter_dirs
if chapter_dir in chapters
]
chapter_markdowns = [
'./' + chapter_dir + '/' + chapter_dir + '.markdown'
for chapter_dir in
chapter_dirs
]
chapter_markdowns_exist = [
envoy.run('test -f ' + chapter_markdown).status_code
for chapter_markdown in
chapter_markdowns
]
process_chapters = [
chapter_markdown
for chapter_markdown, process in
zip(chapter_markdowns, chapter_markdowns_exist)
if process == 0
]
chapter_names = [
getbasename(chapter)
for chapter in
chapter_dirs
]
image_paths = [
'./blockcode/blockcode-images',
'./ci/ci-images',
'./cluster/cluster-images',
'./contingent/contingent-images',
'./crawler/crawler-images',
'./data-store/data-store-images',
'./flow-shop/flow-shop-images',
'./functionalDB/functionalDB-images',
'./image-filters/image-filters-images',
'./interpreter/interpreter-images',
'./modeller/modeller-images',
'./objmodel/objmodel-images',
'./ocr/ocr-images',
'./pedometer/pedometer-images',
'./same-origin-policy/same-origin-policy-images',
'./sampler/sampler-images',
'./spreadsheet/spreadsheet-images',
'./web-server/web-server-images',
]
run('cp -r minutiae/pdf/ tex')
with open('tex/500L.tex', 'w') as out:
with open('tex/500L.template.tex') as template:
lines = template.readlines()
for line in lines:
if 'chapterchapterchapter' in line:
out.write(
'\n'.join(
'\include{%s}\n' % (chapter_name)
for chapter_name in chapter_names
)
)
else:
out.write(line)
if pdf:
for imgpath in image_paths:
run('cp -a {imgpath} tex/'.format(imgpath=imgpath))
for chapter_markdown in process_chapters:
pandoc_cmd(chapter_markdown)
build_pdf()
if epub:
for imgpath in image_paths:
run('cp -a {imgpath} epub/'.format(imgpath=imgpath))
run('cp minutiae/html/introduction.md epub/introduction.markdown')
build_epub(process_chapters, pandoc_epub)
if mobi and not epub:
print('Cannot build .mobi; depends on .epub.')
print('Use --epub --mobi to build .mobi file.')
elif mobi:
build_mobi()
if html:
for imgpath in image_paths:
run('cp -a {imgpath} html/content/pages/'.format(imgpath=imgpath))
run('cp minutiae/html/introduction.md html/content/pages/.')
build_html(process_chapters)
for imgpath in image_paths:
run('cp -a {imgpath} html/output/pages/'.format(imgpath=imgpath))
def build_pdf():
os.chdir('tex')
run('pdflatex -interaction nonstopmode 500L')
os.chdir('..')
run('mv tex/500L.pdf output/')
def build_epub(chapter_markdowns, pandoc_epub):
basenames = [
os.path.splitext(
os.path.split(chapter_markdown)[1]
)[0] + '.markdown'
for chapter_markdown in chapter_markdowns
]
temp = 'python _build/preprocessor.py --chapter {chapnum} --output=epub/{basename}.markdown.1 --latex {md}'
for i, markdown in enumerate(chapter_markdowns):
basename = os.path.splitext(os.path.split(markdown)[1])[0]
run(temp.format(md=markdown, basename=basename, chapnum=i+1))
os.chdir('epub')
temp = '../_build/increaseheaders.sh {basename}.markdown.1 {basename}.markdown {chapnum}'
for i, markdown in enumerate(chapter_markdowns):
basename = os.path.splitext(os.path.split(markdown)[1])[0]
run(temp.format(md=markdown, basename=basename, chapnum=i+1))
pandoc_path = 'pandoc'
cmd = '{pandoc} --chapters -S -f markdown+mmd_title_block --highlight-style=kate -o 500L.epub epubtitle.txt introduction.markdown {markdowns}'
if pandoc_epub:
run(cmd.format(pandoc=pandoc_path, markdowns=' '.join(basenames)))
print((cmd.format(pandoc=pandoc_path, markdowns=' '.join(basenames))))
# import subprocess as sp
# output = ' '.join(open('image-list.txt').read().splitlines())
# print 'zip 500L.epub META-INF mimetype nav.xhtml toc.ncx stylesheet.css content.opf ' + output
# sp.check_output(
# 'zip 500L.epub META-INF mimetype nav.xhtml toc.ncx stylesheet.css content.opf ' + output,
# shell=True)
# if os.path.isdir('tmp-epub-contents'):
# run('rm -r tmp-epub-contents')
# os.mkdir('tmp-epub-contents')
# sp.check_output(
# 'unzip 500L.epub -d tmp-epub-contents/',
# shell=True,
# )
# sp.check_output(
# 'rsync -a tmp-epub-contents/* ./',
# shell=True
# )
# run('rm -r tmp-epub-contents')
run('cp 500L.epub ../output/500L.epub')
os.chdir('..')
def build_mobi():
run('ebook-convert output/500L.epub output/500L.mobi')
def build_html(chapter_markdowns):
run('mkdir -p html/content/pages')
temp = 'python _build/preprocessor.py --chapter {chap} --html-refs --output={md}.1 --latex {md}'
temp2 = 'pandoc --csl=minutiae/pdf/ieee.csl --mathjax -t html -f markdown+citations -o html/content/pages/{basename}.md {md}.1'
temp3 = './_build/fix_html_title.sh html/content/pages/{basename}.md'
for i, markdown in enumerate(chapter_markdowns):
basename = os.path.splitext(os.path.split(markdown)[1])[0]
run(temp.format(chap=i+1, md=markdown, basename=basename))
run(temp2.format(md=markdown, basename=basename))
run(temp3.format(md=markdown, basename=basename))
os.chdir('html')
run('make html')
os.chdir('..')
def getbasename(chapter_markdown):
import os
basename = os.path.splitext(
os.path.split(chapter_markdown)[1]
)[0]
return basename
def _pandoc_cmd(chapter_markdown):
pandoc_path = 'pandoc'
# tex/md because that's where the preprocessed markdowns end up
temp = '{pandoc} -V chaptertoken={chaptertoken} -t latex --chapters -S -f markdown+mmd_title_block+tex_math_dollars --template=tex/chaptertemplate.tex --no-highlight -o tex/{basename}.tex.1 tex/{md}'
basename = getbasename(chapter_markdown)
result = temp.format(pandoc=pandoc_path, basename=basename, md=chapter_markdown, chaptertoken='s:' + basename)
return result
def preprocessor_command(chapter_markdown):
temp = 'python _build/preprocessor.py --output=tex/{basename}.markdown --markdown {md}'
basename = getbasename(chapter_markdown)
result = temp.format(basename=basename, md=chapter_markdown)
print(result)
return (result, basename)
def postprocessor_command(basename):
temp = 'python _build/postprocessor.py --output=tex/{basename}.tex tex/{basename}.tex.1'
return temp.format(basename=basename)
def pandoc_cmd(chapter_markdown):
cmd, basename = preprocessor_command(chapter_markdown)
result = envoy.run(cmd)
new_chapter_markdown = basename + '.markdown'
if result.status_code != 0:
print((result.std_err))
else:
print((result.std_out))
result = envoy.run(_pandoc_cmd(new_chapter_markdown))
if result.status_code != 0:
print((result.std_err))
else:
print((result.std_out))
result2 = envoy.run(postprocessor_command(basename))
return result2
def run(cmd):
print(cmd)
result = envoy.run(cmd)
print((result.std_out))
print((result.std_err))
return result
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('chapters', nargs='*')
parser.add_argument('--epub', action='store_true', default=False)
parser.add_argument('--mobi', action='store_true', default=False)
parser.add_argument('--pdf', action='store_true', default=False)
parser.add_argument('--html', action='store_true', default=False)
parser.add_argument('--pandoc-epub', action='store_true', default=False)
args = parser.parse_args()
main(chapters=args.chapters, epub=args.epub, pdf=args.pdf, html=args.html, mobi=args.mobi, pandoc_epub=args.pandoc_epub)
| 34.058824 | 203 | 0.623489 |
ace01d462613b9d6543b57f0e4f18b4d585fc27c | 5,429 | py | Python | sdk/network/azure-mgmt-network/azure/mgmt/network/v2019_11_01/aio/operations_async/_load_balancer_network_interfaces_operations_async.py | LianwMS/azure-sdk-for-python | 612d7bca9de86ee1bd1fa59291d7bf897ba9213f | [
"MIT"
] | 2 | 2019-05-17T21:24:53.000Z | 2020-02-12T11:13:42.000Z | sdk/network/azure-mgmt-network/azure/mgmt/network/v2019_11_01/aio/operations_async/_load_balancer_network_interfaces_operations_async.py | LianwMS/azure-sdk-for-python | 612d7bca9de86ee1bd1fa59291d7bf897ba9213f | [
"MIT"
] | 15 | 2019-07-12T18:18:04.000Z | 2019-07-25T20:55:51.000Z | sdk/network/azure-mgmt-network/azure/mgmt/network/v2019_11_01/aio/operations_async/_load_balancer_network_interfaces_operations_async.py | LianwMS/azure-sdk-for-python | 612d7bca9de86ee1bd1fa59291d7bf897ba9213f | [
"MIT"
] | 2 | 2020-05-21T22:51:22.000Z | 2020-05-26T20:53:01.000Z | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar
import warnings
from azure.core.async_paging import AsyncItemPaged, AsyncList
from azure.core.exceptions import HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
from azure.mgmt.core.exceptions import ARMErrorFormat
from ... import models
T = TypeVar('T')
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
class LoadBalancerNetworkInterfacesOperations:
"""LoadBalancerNetworkInterfacesOperations async operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.network.v2019_11_01.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = models
def __init__(self, client, config, serializer, deserializer) -> None:
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
def list(
self,
resource_group_name: str,
load_balancer_name: str,
**kwargs
) -> AsyncIterable["models.NetworkInterfaceListResult"]:
"""Gets associated load balancer network interfaces.
:param resource_group_name: The name of the resource group.
:type resource_group_name: str
:param load_balancer_name: The name of the load balancer.
:type load_balancer_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either NetworkInterfaceListResult or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.network.v2019_11_01.models.NetworkInterfaceListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.NetworkInterfaceListResult"]
error_map = {404: ResourceNotFoundError, 409: ResourceExistsError}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2019-11-01"
def prepare_request(next_link=None):
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'loadBalancerName': self._serialize.url("load_balancer_name", load_balancer_name, 'str'),
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = 'application/json'
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('NetworkInterfaceListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/networkInterfaces'} # type: ignore
| 47.622807 | 192 | 0.668816 |
ace01d46f636e3a3328dd27fc80b31a95db6f8fa | 8,447 | py | Python | src/bag3_testbenches/schematic/analog_tb_tran.py | zhaokai-l/bag3_testbenches | 334f0f0ab4eae2931c3ede5471b152329840bf86 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | src/bag3_testbenches/schematic/analog_tb_tran.py | zhaokai-l/bag3_testbenches | 334f0f0ab4eae2931c3ede5471b152329840bf86 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | src/bag3_testbenches/schematic/analog_tb_tran.py | zhaokai-l/bag3_testbenches | 334f0f0ab4eae2931c3ede5471b152329840bf86 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | # SPDX-License-Identifier: Apache-2.0
# Copyright 2019 Blue Cheetah Analog Design Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Dict, Any, Sequence, Optional, Callable, List, Mapping
import json
import pkg_resources
from pathlib import Path
from bag.design.module import Module
from bag.design.database import ModuleDB
from bag.util.immutable import Param
from bag3_liberty.data import parse_cdba_name, BusRange
# noinspection PyPep8Naming
class bag3_testbenches__analog_tb_tran(Module):
"""Schematic generator for transient simulation of analog blocks.
"""
yaml_file = pkg_resources.resource_filename(__name__,
str(Path('netlist_info',
'analog_tb_tran.yaml')))
def __init__(self, database: ModuleDB, params: Param, **kwargs: Any) -> None:
Module.__init__(self, self.yaml_file, database, params, **kwargs)
@classmethod
def get_params_info(cls) -> Dict[str, str]:
return dict(
dut_lib='Transistor DUT library name.',
dut_cell='Transistor DUT cell name.',
in_file_list='input PWL waveform file list.',
clk_file_list='clk PWL waveform file list.',
load_list='output load capacitance list.',
vbias_list='List of voltage biases.',
src_list='List of other sources.',
dut_conns='DUT connection dictionary.',
dut_params='DUT design parameters.',
no_conns='List of non-connected nets',
other_list='Other necessary device list'
)
@classmethod
def get_default_param_values(cls) -> Dict[str, Any]:
return dict(
load_list=None,
vbias_list=None,
dut_conns={},
dut_params=None,
no_conns=None,
in_file_list=[],
clk_file_list=[],
src_list=[],
other_list=[],
)
def design(self, dut_lib: str, dut_cell: str,
in_file_list: Sequence[Sequence[str]],
clk_file_list: Sequence[Sequence[str]],
load_list: Optional[Sequence[Sequence[str]]],
vbias_list: Optional[Sequence[Sequence[str]]],
other_list: Optional[List[Mapping[str, Any]]],
dut_conns: Dict[str, str],
dut_params: Optional[Param],
no_conns: Sequence[str],
src_list: Sequence[Mapping[str, Any]]) -> None:
"""Design the testbench.
The elements of parameter lists are either (pos_term, param) or
(pos_term, neg_term, param), where pos_term/neg_term are the positive/negative
terminals of the voltage sources or capacitors. The negative terminal
defaults to VSS if not specified.
for ``load_list`` and ``vbias_list``, if None is given (the default), then
the default load/bias voltages will be used (the ones shown in schematic
template). If an empty list is given, then they'll be removed entirely.
Parameters
----------
dut_lib : str
DUT library name
dut_cell : str
DUT cell name
in_file_list : Sequence[Sequence[str]]
List of PWL input stimuli files
clk_file_list : Sequence[Sequence[str]]
List of PWL clk stimuli files
load_list : Optional[Sequence[Sequence[str]]]
List of ideal capacitor loads
other_list : Optional[Sequence[Sequence[str]]]
List of other devices for tb
vbias_list : Optional[Sequence[Sequence[str]]]
List of voltage biases
dut_conns : Dict[str, str]
DUT connection dictionary
dut_params: Optional[Param]
Replace the DUT statically if empty, otherwise call design with dut_params.
no_conns: List[str]
Connects the content of this list to noConn.
src_list : Sequence[Mapping[str, Any]]
list of sources and loads.
"""
if no_conns:
len_no_conn = 0
for pin in no_conns:
basename, bus_range = parse_cdba_name(pin)
if bus_range is None:
len_no_conn += 1
else:
len_no_conn += max(bus_range.start, bus_range.stop)+1
self.rename_instance('XNC', f'XNC<{len_no_conn - 1}:0>',
[('noConn', ','.join(no_conns))])
else:
self.delete_instance('XNC')
if vbias_list is None:
vbias_list = [('VDD', 'vdd')]
# combine src_list and load_list
src_load_list = list(src_list)
if load_list:
for cap_info in load_list:
if len(cap_info) == 2:
pos_term, val = cap_info
neg_term = 'VSS'
elif len(cap_info) == 3:
pos_term, neg_term, val = cap_info
else:
raise ValueError(f'Cannot parse cap element: {cap_info}')
src_load_list.append(dict(type='cap', lib='analogLib', value=val,
conns=dict(PLUS=pos_term, MINUS=neg_term)))
# setup DUT
dut_static = dut_params is None
self.replace_instance_master('XDUT', dut_lib, dut_cell, static=dut_static,
keep_connections=True)
if not dut_static:
self.instances['XDUT'].design(**dut_params)
self.reconnect_instance('XDUT', ((k, v) for k, v in dut_conns.items()))
# setup PWL files
def get_path_str(fname: str) -> str:
return json.dumps(str(Path(fname).resolve()))
self._array_and_set_params('VIN', in_file_list, 'fileName', get_path_str)
self._array_and_set_params('VCLK', clk_file_list, 'fileName', get_path_str)
# setup voltage biases
self._array_and_set_params('VSUP', vbias_list, 'vdc', None)
# setup sources and loads
self.design_sources_and_loads(src_load_list, default_name='CLOAD')
if other_list:
name_list = []
element_list = []
for other_dev in other_list:
name_list.append(other_dev['name'])
element_list.append((other_dev['name'], other_dev['conn'], other_dev['params']))
self.array_instance('XSW', inst_name_list=name_list)
for name, conns, val_dict in element_list:
inst = self.instances[name]
for k, v in val_dict.items():
inst.set_param(k, v)
self.reconnect_instance(name, conns.items())
else:
self.remove_instance('XSW')
def _array_and_set_params(self, inst_name: str, info_list: Sequence[Sequence[str]],
param_name: str, fun: Optional[Callable[[str], str]]) -> None:
if info_list:
inst_term_list = []
param_list = []
for ele in info_list:
if len(ele) == 2:
pos_term = ele[0]
neg_term = 'VSS'
val = ele[1]
elif len(ele) == 3:
pos_term = ele[0]
neg_term = ele[1]
val = ele[2]
else:
raise ValueError(f'Cannot parse list element: {ele}')
cur_name = f'X{pos_term.upper()}'
inst_term_list.append((cur_name, [('PLUS', pos_term), ('MINUS', neg_term)]))
param_list.append(val if fun is None else fun(val))
self.array_instance(inst_name, inst_term_list=inst_term_list)
for (name, _), param in zip(inst_term_list, param_list):
self.instances[name].set_param(param_name, param)
else:
self.remove_instance(inst_name)
| 40.033175 | 96 | 0.58068 |
ace01e38a40ab2b851266b172228e7ac05e47417 | 772 | py | Python | var/spack/repos/builtin/packages/r-dicekriging/package.py | xiki-tempula/spack | 9d66c05e93ab8a933fc59915040c0e0c86a4aac4 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 9 | 2018-04-18T07:51:40.000Z | 2021-09-10T03:56:57.000Z | var/spack/repos/builtin/packages/r-dicekriging/package.py | xiki-tempula/spack | 9d66c05e93ab8a933fc59915040c0e0c86a4aac4 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 907 | 2018-04-18T11:17:57.000Z | 2022-03-31T13:20:25.000Z | var/spack/repos/builtin/packages/r-dicekriging/package.py | xiki-tempula/spack | 9d66c05e93ab8a933fc59915040c0e0c86a4aac4 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | 29 | 2018-11-05T16:14:23.000Z | 2022-02-03T16:07:09.000Z | # Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class RDicekriging(RPackage):
"""Estimation, validation and prediction of kriging models. Important
functions : km, print.km, plot.km, predict.km."""
homepage = "http://dice.emse.fr/"
url = "https://cloud.r-project.org/src/contrib/DiceKriging_1.5.5.tar.gz"
list_url = "https://cloud.r-project.org/src/contrib/Archive/DiceKriging"
version('1.5.6', sha256='25466d2db9f17083d1c7b9545e5ec88f630be934f9373c2f7b36c38de4e64e92')
version('1.5.5', sha256='55fe161f867a0c3772023c3047041b877aa54d29cb474ec87293ec31cc5cb30c')
| 40.631579 | 95 | 0.747409 |
ace01e8a4a4140a097878a3bfbcc7795ed9e0ce4 | 7,440 | py | Python | share/dynamo-to-share/src/stream_to_uni/index.py | vendia/examples | 691ad07e880b386114e7bdf4603d047041121c5b | [
"Apache-2.0"
] | 9 | 2021-02-19T14:53:40.000Z | 2022-01-21T20:03:17.000Z | share/dynamo-to-share/src/stream_to_uni/index.py | vendia/examples | 691ad07e880b386114e7bdf4603d047041121c5b | [
"Apache-2.0"
] | 1 | 2021-05-21T18:31:28.000Z | 2021-05-21T18:31:28.000Z | share/dynamo-to-share/src/stream_to_uni/index.py | vendia/examples | 691ad07e880b386114e7bdf4603d047041121c5b | [
"Apache-2.0"
] | 1 | 2022-01-28T18:39:58.000Z | 2022-01-28T18:39:58.000Z | import os
import urllib3
import boto3
from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport
urllib3.disable_warnings()
# Vendia Share node data
share_node_url = os.getenv('SHARE_NODE_URL')
share_node_api_key = os.getenv('SHARE_NODE_API_KEY')
transport=RequestsHTTPTransport(
url=share_node_url,
use_json=True,
headers={
"Content-type": "application/json",
"x-api-key": share_node_api_key
},
verify=False,
retries=3,
)
gql_client = Client(
transport=transport,
fetch_schema_from_transport=True,
)
def add_to_share(
item_name,
item_number,
quantity,
unit_price,
tags
):
'''Add selected inventory data to Vendia Share node
Parameters
----------
item_name: string, required
item_number: string, required
quantity: number, required
tags: list, required
Returns
-------
result: dict
Result of the GraphQL query operation
'''
params = {
"itemName": item_name,
"itemNumber": item_number,
"quantity": quantity,
"unitPrice": unit_price,
"tags": tags
}
insert_query = gql(
"""
mutation addItem(
$itemName: String!,
$itemNumber: String!,
$quantity: Int!,
$unitPrice: Float!,
$tags: [String!]
) {
add_Inventory_async(
input: {
itemName: $itemName,
itemNumber: $itemNumber,
quantity: $quantity,
tags: $tags,
unitPrice: $unitPrice
}
) {
error
result {
_id
}
}
}
"""
)
try:
result = gql_client.execute(
insert_query,
variable_values=params
)
except Exception as e:
raise Exception(f'Error: {str(e)}')
return(result)
def remove_from_share(
item_number
):
'''Remove inventory item from Vendia Share node
Parameters
----------
item_number: string, required
Returns
-------
result: dict
Result of the GraphQL query operation
'''
# Determine the Vendia id of the item_number
params = {
"itemNumber": item_number
}
search_query = gql(
"""
query listItem(
$itemNumber: String!
) {
list_InventoryItems(
filter: {
itemNumber: {
eq: $itemNumber
}
}
) {
_InventoryItems {
_id
}
}
}
"""
)
try:
result = gql_client.execute(
search_query,
variable_values=params
)
except Exception as e:
raise Exception(f'Error: {str(e)}')
item_id = result['list_InventoryItems']['_InventoryItems'][0]['_id']
# Remove the item from Vendia Share
params = {
"_id": item_id
}
remove_query = gql(
"""
mutation removeItem(
$_id: ID!
) {
remove_Inventory_async(
id: $_id
) {
error
result {
_id
}
}
}
"""
)
try:
result = gql_client.execute(
remove_query,
variable_values=params
)
except Exception as e:
raise Exception(f'Error: {str(e)}')
return(result)
def update_in_share(
item_name,
item_number,
quantity,
unit_price,
tags
):
'''Update inventory item from Vendia Share node
Parameters
----------
item_name: string, required
item_number: string, required
quantity: number, required
unit_price: number, required
tags: list, required
Returns
-------
result: dict
Result of the GraphQL query operation
'''
# Determine the Vendia id of the item_number
params = {
"itemNumber": item_number
}
search_query = gql(
"""
query listItem(
$itemNumber: String!
) {
list_InventoryItems(
filter: {
itemNumber: {
eq: $itemNumber
}
}
) {
_InventoryItems {
_id
}
}
}
"""
)
try:
result = gql_client.execute(
search_query,
variable_values=params
)
except Exception as e:
raise Exception(f'Error: {str(e)}')
item_id = result['list_InventoryItems']['_InventoryItems'][0]['_id']
# Update the item in Vendia Share
params = {
"_id": item_id,
"itemName": item_name,
"itemNumber": item_number,
"quantity": quantity,
"unitPrice": unit_price,
"tags": tags
}
update_query = gql(
"""
mutation updateItem(
$_id: ID!,
$itemName: String!,
$itemNumber: String!,
$quantity: Int!,
$unitPrice: Float!,
$tags: [String!]
) {
put_Inventory_async(
id: $_id,
input: {
itemName: $itemName,
itemNumber: $itemNumber,
quantity: $quantity,
unitPrice: $unitPrice,
tags: $tags
}
) {
error
result {
_id
}
}
}
"""
)
try:
result = gql_client.execute(
update_query,
variable_values=params
)
except Exception as e:
raise Exception(f'Error: {str(e)}')
return(result)
def handler(event, context):
for record in event['Records']:
event_name = record["eventName"]
if event_name == 'INSERT':
new_image = record['dynamodb']['NewImage']
tags = [ tag["S"] for tag in new_image["tags"]["L"]]
result = add_to_share(
item_name=new_image["item_name"]["S"],
item_number=new_image["item_number"]["S"],
quantity=int(new_image["quantity"]["N"]),
unit_price=float(new_image["unit_price"]["N"]),
tags=tags
)
elif event_name == 'REMOVE':
result = remove_from_share(
item_number=record['dynamodb']['Keys']['item_number']['S']
)
elif event_name == 'MODIFY':
tags = [ tag["S"] for tag in record["dynamodb"]["NewImage"]["tags"]["L"]]
result = update_in_share(
item_name=record["dynamodb"]["NewImage"]["item_name"]["S"],
item_number=record["dynamodb"]["NewImage"]["item_number"]["S"],
quantity=int(record["dynamodb"]["NewImage"]["quantity"]["N"]),
unit_price=float(record["dynamodb"]["NewImage"]["unit_price"]["N"]),
tags=tags
)
else:
print(f"We don't handle {event_name} yet")
print(event)
print(result)
| 23.034056 | 85 | 0.477554 |
ace01f6f2820eaa929ad0c166c648e6eedcffe4f | 11,643 | py | Python | AFSD/common/thumos_dataset.py | Anonymous502/Ban-for-eccv | 4d75077bc0c6a6ed7733330981c579a731fcb715 | [
"BSD-3-Clause"
] | null | null | null | AFSD/common/thumos_dataset.py | Anonymous502/Ban-for-eccv | 4d75077bc0c6a6ed7733330981c579a731fcb715 | [
"BSD-3-Clause"
] | null | null | null | AFSD/common/thumos_dataset.py | Anonymous502/Ban-for-eccv | 4d75077bc0c6a6ed7733330981c579a731fcb715 | [
"BSD-3-Clause"
] | null | null | null | import numpy as np
import pandas as pd
import torch
import os
from torch.utils.data import Dataset, DataLoader
import tqdm
from AFSD.common import videotransforms
from AFSD.common.config import config
import random
import math
def get_class_index_map(class_info_path='thumos_annotations/Class Index_Detection.txt'):
txt = np.loadtxt(class_info_path, dtype=str)
originidx_to_idx = {}
idx_to_class = {}
for idx, l in enumerate(txt):
originidx_to_idx[int(l[0])] = idx + 1
idx_to_class[idx + 1] = l[1]
return originidx_to_idx, idx_to_class
def get_video_info(video_info_path):
df_info = pd.DataFrame(pd.read_csv(video_info_path)).values[:]
video_infos = {}
for info in df_info:
video_infos[info[0]] = {
'fps': info[1],
'sample_fps': info[2],
'count': info[3],
'sample_count': info[4]
}
return video_infos
def get_video_anno(video_infos,
video_anno_path):
df_anno = pd.DataFrame(pd.read_csv(video_anno_path)).values[:]
originidx_to_idx, idx_to_class = get_class_index_map()
video_annos = {}
for anno in df_anno:
video_name = anno[0]
originidx = anno[2]
start_frame = anno[-2]
end_frame = anno[-1]
count = video_infos[video_name]['count']
sample_count = video_infos[video_name]['sample_count']
ratio = sample_count * 1.0 / count
start_gt = start_frame * ratio
end_gt = end_frame * ratio
class_idx = originidx_to_idx[originidx]
if video_annos.get(video_name) is None:
video_annos[video_name] = [[start_gt, end_gt, class_idx]]
else:
video_annos[video_name].append([start_gt, end_gt, class_idx])
return video_annos
def annos_transform(annos, clip_length):
res = []
for anno in annos:
res.append([
anno[0] * 1.0 / clip_length,
anno[1] * 1.0 / clip_length,
anno[2]
])
return res
def split_videos(video_infos,
video_annos,
clip_length=config['dataset']['training']['clip_length'],
stride=config['dataset']['training']['clip_stride']):
# video_infos = get_video_info(config['dataset']['training']['video_info_path'])
# video_annos = get_video_anno(video_infos,
# config['dataset']['training']['video_anno_path'])
training_list = []
min_anno_dict = {}
for video_name in video_annos.keys():
min_anno = clip_length
sample_count = video_infos[video_name]['sample_count']
annos = video_annos[video_name]
if sample_count <= clip_length:
offsetlist = [0]
min_anno_len = min([x[1] - x[0] for x in annos])
if min_anno_len < min_anno:
min_anno = min_anno_len
else:
offsetlist = list(range(0, sample_count - clip_length + 1, stride))
if (sample_count - clip_length) % stride:
offsetlist += [sample_count - clip_length]
for offset in offsetlist:
left, right = offset + 1, offset + clip_length
cur_annos = []
save_offset = False
for anno in annos:
max_l = max(left, anno[0])
min_r = min(right, anno[1])
ioa = (min_r - max_l) * 1.0 / (anno[1] - anno[0])
if ioa >= 1.0:
save_offset = True
if ioa >= 0.5:
cur_annos.append([max(anno[0] - offset, 1),
min(anno[1] - offset, clip_length),
anno[2]])
if len(cur_annos) > 0:
min_anno_len = min([x[1] - x[0] for x in cur_annos])
if min_anno_len < min_anno:
min_anno = min_anno_len
if save_offset:
start = np.zeros([clip_length])
end = np.zeros([clip_length])
action = np.zeros([clip_length])
# import pdb
# pdb.set_trace()
for anno in cur_annos:
s, e, id = anno
d = max((e - s) / 10.0, 2.0)
start_s = np.clip(int(round(s - d / 2.0)), 0, clip_length - 1)
start_e = np.clip(int(round(s + d / 2.0)), 0, clip_length - 1) + 1
start[start_s: start_e] = 1
end_s = np.clip(int(round(e - d / 2.0)), 0, clip_length - 1)
end_e = np.clip(int(round(e + d / 2.0)), 0, clip_length - 1) + 1
end[end_s: end_e] = 1
a_b = int(round(s))
a_e = int(round(e))
action[a_b: a_e] = 1
if a_e + 1 < clip_length:
action[a_e] = 0.7 #0.6 #0.6
action[a_e + 1] = 0.3 #0.3
if a_b - 1 > 0:
action[a_b] = 0.7 #0.6
action[a_b - 1] = 0.3 #0.3
training_list.append({
'video_name': video_name,
'offset': offset,
'annos': cur_annos,
'start': start,
'end': end,
'action': action
})
min_anno_dict[video_name] = math.ceil(min_anno)
return training_list, min_anno_dict
def load_video_data(video_infos, npy_data_path):
data_dict = {}
print('loading video frame data ...')
for video_name in tqdm.tqdm(list(video_infos.keys()), ncols=0):
data = np.load(os.path.join(npy_data_path, video_name + '.npy'))
data = np.transpose(data, [3, 0, 1, 2])
data_dict[video_name] = data
return data_dict
class THUMOS_Dataset(Dataset):
def __init__(self, data_dict,
video_infos,
video_annos,
clip_length=config['dataset']['training']['clip_length'],
crop_size=config['dataset']['training']['crop_size'],
stride=config['dataset']['training']['clip_stride'],
rgb_norm=True,
training=True,
origin_ratio=0.5):
self.training_list, self.th = split_videos(
video_infos,
video_annos,
clip_length,
stride
)
# np.random.shuffle(self.training_list)
self.data_dict = data_dict
self.clip_length = clip_length
self.crop_size = crop_size
self.random_crop = videotransforms.RandomCrop(crop_size)
self.random_flip = videotransforms.RandomHorizontalFlip(p=0.5)
self.center_crop = videotransforms.CenterCrop(crop_size)
self.rgb_norm = rgb_norm
self.training = training
self.origin_ratio = origin_ratio
def __len__(self):
return len(self.training_list)
def get_bg(self, annos, min_action):
annos = [[anno[0], anno[1]] for anno in annos]
times = []
for anno in annos:
times.extend(anno)
times.extend([0, self.clip_length - 1])
times.sort()
regions = [[times[i], times[i + 1]] for i in range(len(times) - 1)]
regions = list(filter(
lambda x: x not in annos and math.floor(x[1]) - math.ceil(x[0]) > min_action, regions))
# regions = list(filter(lambda x:x not in annos, regions))
region = random.choice(regions)
return [math.ceil(region[0]), math.floor(region[1])]
def augment_(self, input, annos, th):
'''
input: (c, t, h, w)
target: (N, 3)
'''
try:
gt = random.choice(list(filter(lambda x: x[1] - x[0] > 2 * th, annos)))
# gt = random.choice(annos)
except IndexError:
return input, annos, False
gt_len = gt[1] - gt[0]
region = range(math.floor(th), math.ceil(gt_len - th))
t = random.choice(region) + math.ceil(gt[0])
l_len = math.ceil(t - gt[0])
r_len = math.ceil(gt[1] - t)
try:
bg = self.get_bg(annos, th)
except IndexError:
return input, annos, False
start_idx = random.choice(range(bg[1] - bg[0] - th)) + bg[0]
end_idx = start_idx + th
new_input = input.clone()
# annos.remove(gt)
if gt[1] < start_idx:
new_input[:, t:t + th, ] = input[:, start_idx:end_idx, ]
new_input[:, t + th:end_idx, ] = input[:, t:start_idx, ]
new_annos = [[gt[0], t], [t + th, th + gt[1]], [t + 1, t + th - 1]]
# new_annos = [[t-math.ceil(th/5), t+math.ceil(th/5)],
# [t+th-math.ceil(th/5), t+th+math.ceil(th/5)],
# [t+1, t+th-1]]
else:
new_input[:, start_idx:t - th] = input[:, end_idx:t, ]
new_input[:, t - th:t, ] = input[:, start_idx:end_idx, ]
new_annos = [[gt[0] - th, t - th], [t, gt[1]], [t - th + 1, t - 1]]
# new_annos = [[t-th-math.ceil(th/5), t-th+math.ceil(th/5)],
# [t-math.ceil(th/5), t+math.ceil(th/5)],
# [t-th+1, t-1]]
return new_input, new_annos, True
def augment(self, input, annos, th, max_iter=10):
flag = True
i = 0
while flag and i < max_iter:
new_input, new_annos, flag = self.augment_(input, annos, th)
i += 1
return new_input, new_annos, flag
def __getitem__(self, idx):
sample_info = self.training_list[idx]
video_data = self.data_dict[sample_info['video_name']]
offset = sample_info['offset']
annos = sample_info['annos']
th = self.th[sample_info['video_name']]
input_data = video_data[:, offset: offset + self.clip_length]
c, t, h, w = input_data.shape
if t < self.clip_length:
# padding t to clip_length
pad_t = self.clip_length - t
zero_clip = np.zeros([c, pad_t, h, w], input_data.dtype)
input_data = np.concatenate([input_data, zero_clip], 1)
# random crop and flip
if self.training:
input_data = self.random_flip(self.random_crop(input_data))
else:
input_data = self.center_crop(input_data)
# import pdb;pdb.set_trace()
input_data = torch.from_numpy(input_data).float()
if self.rgb_norm:
input_data = (input_data / 255.0) * 2.0 - 1.0
ssl_input_data, ssl_annos, flag = self.augment(input_data, annos, th, 1)
annos = annos_transform(annos, self.clip_length)
target = np.stack(annos, 0)
ssl_target = np.stack(ssl_annos, 0)
scores = np.stack([
sample_info['start'],
sample_info['end']
], axis=0)
scores = torch.from_numpy(scores.copy()).float()
action = sample_info['action']
return input_data, target, scores, ssl_input_data, ssl_target, flag, action
def detection_collate(batch):
targets = []
clips = []
scores = []
ssl_targets = []
ssl_clips = []
flags = []
action = []
for sample in batch:
clips.append(sample[0])
targets.append(torch.FloatTensor(sample[1]))
scores.append(sample[2])
ssl_clips.append(sample[3])
ssl_targets.append(torch.FloatTensor(sample[4]))
flags.append(sample[5])
action.append(sample[6])
return torch.stack(clips, 0), targets, torch.stack(scores, 0), \
torch.stack(ssl_clips, 0), ssl_targets, flags, action
| 36.728707 | 99 | 0.538092 |
ace02119af8d5bf9d12bdc7d929610ed927dc90c | 4,467 | py | Python | 2_Decoupled_Neural_Network/1_Red_Box_Case.py | JaeDukSeo/Only_Numpy_Basic | 3d42f4a9edcdc054831224af059425aa8e3c200d | [
"MIT"
] | 26 | 2017-11-04T05:18:27.000Z | 2021-11-08T11:18:46.000Z | 2_Decoupled_Neural_Network/1_Red_Box_Case.py | JaeDukSeo/Only_Numpy_Basic | 3d42f4a9edcdc054831224af059425aa8e3c200d | [
"MIT"
] | null | null | null | 2_Decoupled_Neural_Network/1_Red_Box_Case.py | JaeDukSeo/Only_Numpy_Basic | 3d42f4a9edcdc054831224af059425aa8e3c200d | [
"MIT"
] | 9 | 2018-03-01T10:07:37.000Z | 2021-12-27T02:15:28.000Z |
import numpy as np
import sys,time
def generate_dataset(output_dim = 8,num_examples=1000):
def int2vec(x,dim=output_dim):
out = np.zeros(dim)
binrep = np.array(list(np.binary_repr(x))).astype('int')
out[-len(binrep):] = binrep
return out
x_left_int = (np.random.rand(num_examples) * 2**(output_dim - 1)).astype('int')
x_right_int = (np.random.rand(num_examples) * 2**(output_dim - 1)).astype('int')
print(x_left_int[0])
print(x_right_int[0])
y_int = x_left_int + x_right_int
print(y_int[0])
x = list()
for i in range(len(x_left_int)):
x.append(np.concatenate((int2vec(x_left_int[i]),int2vec(x_right_int[i]))))
y = list()
for i in range(len(y_int)):
y.append(int2vec(y_int[i]))
x = np.array(x)
y = np.array(y)
return (x,y)
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# the special way of derivative
def sigmoid_out2deriv(out):
return out * (1 - out)
np.random.seed(1234)
num_examples = 1000
output_dim = 12
iterations = 2000
x,y = generate_dataset(num_examples=num_examples, output_dim = output_dim)
batch_size = 1000
alpha = 0.03
class DNI(object):
def __init__(self,input_dim, output_dim,nonlin,nonlin_deriv,alpha ):
self.weights = (np.random.randn(input_dim, output_dim) * 0.2) - 0.1
self.weights_synthetic_grads = (np.random.randn(output_dim,output_dim) * 0.2) - 0.1
self.nonlin = nonlin
self.nonlin_deriv = nonlin_deriv
self.alpha = alpha
def forward_and_synthetic_update(self,input):
# Traditional Forward Feed Process
self.input = input
self.output = self.nonlin(self.input.dot(self.weights))
#
self.synthetic_gradient = self.output.dot(self.weights_synthetic_grads)
self.weight_synthetic_gradient = self.synthetic_gradient * self.nonlin_deriv(self.output)
self.weights += self.input.T.dot(self.weight_synthetic_gradient) * self.alpha
return self.weight_synthetic_gradient.dot(self.weights.T), self.output
def update_synthetic_weights(self,true_gradient):
self.synthetic_gradient_delta = self.synthetic_gradient - true_gradient
self.weights_synthetic_grads += self.output.T.dot(self.synthetic_gradient_delta) * self.alpha
# input = 24, output = 12 , layer_1_dim = 128, layer_2_dim = 64
start = time.time()
input_dim = len(x[0])
layer_1_dim = 128
layer_2_dim = 64
output_dim = len(y[0])
layer_1 = DNI(input_dim,layer_1_dim,sigmoid,sigmoid_out2deriv,alpha)
layer_2 = DNI(layer_1_dim,layer_2_dim,sigmoid,sigmoid_out2deriv,alpha)
layer_3 = DNI(layer_2_dim, output_dim,sigmoid, sigmoid_out2deriv,alpha)
for iter in range(iterations):
error = 0
batch_x = x
batch_y = y
_, layer_1_out = layer_1.forward_and_synthetic_update(batch_x)
layer_1_delta, layer_2_out = layer_2.forward_and_synthetic_update(layer_1_out)
layer_1.update_synthetic_weights(layer_1_delta)
layer_2_delta, layer_3_out = layer_3.forward_and_synthetic_update(layer_2_out)
layer_2.update_synthetic_weights(layer_2_delta)
layer_3_delta = layer_3_out - batch_y
layer_3.update_synthetic_weights(layer_3_delta)
# This is the true update of the gradient
# layer_3.update_synthetic_weights(layer_3_delta)
# layer_2.update_synthetic_weights(layer_2_delta)
# layer_1.update_synthetic_weights(layer_1_delta)
error += (np.sum(np.abs(layer_3_delta * layer_3_out * (1 - layer_3_out))))
if(error < 0.1):
sys.stdout.write("\rIter:" + str(iter) + " Loss:" + str(error))
break
sys.stdout.write("\rIter:" + str(iter) + " Loss:" + str(error))
if(iter % 100 == 0):
print("")
end = time.time()
_, layer_1_out = layer_1.forward_and_synthetic_update(x)
layer_1_delta, layer_2_out = layer_2.forward_and_synthetic_update(layer_1_out)
layer_2_delta, layer_3_out = layer_3.forward_and_synthetic_update(layer_2_out)
for iter in range(10):
print(x[iter][:12].dot(2**np.arange(x[iter][:12].size)[::-1]) )
print(x[iter][12:].dot(2**np.arange(x[iter][:12].size)[::-1]) )
print("-----------")
print(layer_3_out[iter].dot(2**np.arange(x[iter][:12].size)[::-1]))
truteh = x[iter][:12] + x[iter][12:]
print("The truth data: ",truteh.dot(2**np.arange(x[iter][:12].size)[::-1]),'\n')
print("\n\n------------\nTraining Time: ",end - start )
| 31.680851 | 101 | 0.671816 |
ace021ca6e597094ab101bd6395ff24a4a87486e | 150 | py | Python | schedules/apps.py | kabloosh1234/booking-buddy | 886c77398101a60a9617fd6d0f8b6e59321c38bb | [
"MIT"
] | null | null | null | schedules/apps.py | kabloosh1234/booking-buddy | 886c77398101a60a9617fd6d0f8b6e59321c38bb | [
"MIT"
] | 3 | 2021-12-24T17:26:25.000Z | 2022-01-14T23:17:29.000Z | schedules/apps.py | kabloosh1234/booking-buddy | 886c77398101a60a9617fd6d0f8b6e59321c38bb | [
"MIT"
] | 2 | 2021-12-24T17:06:01.000Z | 2021-12-24T17:06:29.000Z | from django.apps import AppConfig
class SchedulesConfig(AppConfig):
default_auto_field = "django.db.models.BigAutoField"
name = "schedules"
| 21.428571 | 56 | 0.766667 |
ace02248562d7db6abe85d6a78e9076caac6108b | 12,570 | py | Python | built-in/TensorFlow/Official/cv/image_classification/MobileNetV2_for_TensorFlow/nets/resnet_utils.py | Ascend/modelzoo | f018cfed33dbb1cc2110b9ea2e233333f71cc509 | [
"Apache-2.0"
] | 12 | 2020-12-13T08:34:24.000Z | 2022-03-20T15:17:17.000Z | built-in/TensorFlow/Official/cv/image_classification/MobileNetV2_for_TensorFlow/nets/resnet_utils.py | Ascend/modelzoo | f018cfed33dbb1cc2110b9ea2e233333f71cc509 | [
"Apache-2.0"
] | 1 | 2022-01-20T03:11:05.000Z | 2022-01-20T06:53:39.000Z | built-in/TensorFlow/Official/cv/image_classification/MobileNetV2_for_TensorFlow/nets/resnet_utils.py | Ascend/modelzoo | f018cfed33dbb1cc2110b9ea2e233333f71cc509 | [
"Apache-2.0"
] | 2 | 2021-07-10T12:40:46.000Z | 2021-12-17T07:55:15.000Z | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# ============================================================================
# Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
## ==============================================================================
"""Contains building blocks for various versions of Residual Networks.
Residual networks (ResNets) were proposed in:
Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385, 2015
More variants were introduced in:
Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Identity Mappings in Deep Residual Networks. arXiv: 1603.05027, 2016
We can obtain different ResNet variants by changing the network depth, width,
and form of residual unit. This module implements the infrastructure for
building them. Concrete ResNet units and full ResNet networks are implemented in
the accompanying resnet_v1.py and resnet_v2.py modules.
Compared to https://github.com/KaimingHe/deep-residual-networks, in the current
implementation we subsample the output activations in the last residual unit of
each block, instead of subsampling the input activations in the first residual
unit of each block. The two implementations give identical results but our
implementation is more memory efficient.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import tensorflow as tf
from tensorflow.contrib import slim as contrib_slim
slim = contrib_slim
class Block(collections.namedtuple('Block', ['scope', 'unit_fn', 'args'])):
"""A named tuple describing a ResNet block.
Its parts are:
scope: The scope of the `Block`.
unit_fn: The ResNet unit function which takes as input a `Tensor` and
returns another `Tensor` with the output of the ResNet unit.
args: A list of length equal to the number of units in the `Block`. The list
contains one (depth, depth_bottleneck, stride) tuple for each unit in the
block to serve as argument to unit_fn.
"""
def subsample(inputs, factor, scope=None):
"""Subsamples the input along the spatial dimensions.
Args:
inputs: A `Tensor` of size [batch, height_in, width_in, channels].
factor: The subsampling factor.
scope: Optional variable_scope.
Returns:
output: A `Tensor` of size [batch, height_out, width_out, channels] with the
input, either intact (if factor == 1) or subsampled (if factor > 1).
"""
if factor == 1:
return inputs
else:
return slim.max_pool2d(inputs, [1, 1], stride=factor, scope=scope)
def conv2d_same(inputs, num_outputs, kernel_size, stride, rate=1, scope=None):
"""Strided 2-D convolution with 'SAME' padding.
When stride > 1, then we do explicit zero-padding, followed by conv2d with
'VALID' padding.
Note that
net = conv2d_same(inputs, num_outputs, 3, stride=stride)
is equivalent to
net = slim.conv2d(inputs, num_outputs, 3, stride=1, padding='SAME')
net = subsample(net, factor=stride)
whereas
net = slim.conv2d(inputs, num_outputs, 3, stride=stride, padding='SAME')
is different when the input's height or width is even, which is why we add the
current function. For more details, see ResnetUtilsTest.testConv2DSameEven().
Args:
inputs: A 4-D tensor of size [batch, height_in, width_in, channels].
num_outputs: An integer, the number of output filters.
kernel_size: An int with the kernel_size of the filters.
stride: An integer, the output stride.
rate: An integer, rate for atrous convolution.
scope: Scope.
Returns:
output: A 4-D tensor of size [batch, height_out, width_out, channels] with
the convolution output.
"""
if stride == 1:
return slim.conv2d(inputs, num_outputs, kernel_size, stride=1, rate=rate,
padding='SAME', scope=scope)
else:
kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
pad_total = kernel_size_effective - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
inputs = tf.pad(
tensor=inputs,
paddings=[[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]])
return slim.conv2d(inputs, num_outputs, kernel_size, stride=stride,
rate=rate, padding='VALID', scope=scope)
@slim.add_arg_scope
def stack_blocks_dense(net, blocks, output_stride=None,
store_non_strided_activations=False,
outputs_collections=None):
"""Stacks ResNet `Blocks` and controls output feature density.
First, this function creates scopes for the ResNet in the form of
'block_name/unit_1', 'block_name/unit_2', etc.
Second, this function allows the user to explicitly control the ResNet
output_stride, which is the ratio of the input to output spatial resolution.
This is useful for dense prediction tasks such as semantic segmentation or
object detection.
Most ResNets consist of 4 ResNet blocks and subsample the activations by a
factor of 2 when transitioning between consecutive ResNet blocks. This results
to a nominal ResNet output_stride equal to 8. If we set the output_stride to
half the nominal network stride (e.g., output_stride=4), then we compute
responses twice.
Control of the output feature density is implemented by atrous convolution.
Args:
net: A `Tensor` of size [batch, height, width, channels].
blocks: A list of length equal to the number of ResNet `Blocks`. Each
element is a ResNet `Block` object describing the units in the `Block`.
output_stride: If `None`, then the output will be computed at the nominal
network stride. If output_stride is not `None`, it specifies the requested
ratio of input to output spatial resolution, which needs to be equal to
the product of unit strides from the start up to some level of the ResNet.
For example, if the ResNet employs units with strides 1, 2, 1, 3, 4, 1,
then valid values for the output_stride are 1, 2, 6, 24 or None (which
is equivalent to output_stride=24).
store_non_strided_activations: If True, we compute non-strided (undecimated)
activations at the last unit of each block and store them in the
`outputs_collections` before subsampling them. This gives us access to
higher resolution intermediate activations which are useful in some
dense prediction problems but increases 4x the computation and memory cost
at the last unit of each block.
outputs_collections: Collection to add the ResNet block outputs.
Returns:
net: Output tensor with stride equal to the specified output_stride.
Raises:
ValueError: If the target output_stride is not valid.
"""
# The current_stride variable keeps track of the effective stride of the
# activations. This allows us to invoke atrous convolution whenever applying
# the next residual unit would result in the activations having stride larger
# than the target output_stride.
current_stride = 1
# The atrous convolution rate parameter.
rate = 1
for block in blocks:
with tf.compat.v1.variable_scope(block.scope, 'block', [net]) as sc:
block_stride = 1
for i, unit in enumerate(block.args):
if store_non_strided_activations and i == len(block.args) - 1:
# Move stride from the block's last unit to the end of the block.
block_stride = unit.get('stride', 1)
unit = dict(unit, stride=1)
with tf.compat.v1.variable_scope('unit_%d' % (i + 1), values=[net]):
# If we have reached the target output_stride, then we need to employ
# atrous convolution with stride=1 and multiply the atrous rate by the
# current unit's stride for use in subsequent layers.
if output_stride is not None and current_stride == output_stride:
net = block.unit_fn(net, rate=rate, **dict(unit, stride=1))
rate *= unit.get('stride', 1)
else:
net = block.unit_fn(net, rate=1, **unit)
current_stride *= unit.get('stride', 1)
if output_stride is not None and current_stride > output_stride:
raise ValueError('The target output_stride cannot be reached.')
# Collect activations at the block's end before performing subsampling.
net = slim.utils.collect_named_outputs(outputs_collections, sc.name, net)
# Subsampling of the block's output activations.
if output_stride is not None and current_stride == output_stride:
rate *= block_stride
else:
net = subsample(net, block_stride)
current_stride *= block_stride
if output_stride is not None and current_stride > output_stride:
raise ValueError('The target output_stride cannot be reached.')
if output_stride is not None and current_stride != output_stride:
raise ValueError('The target output_stride cannot be reached.')
return net
def resnet_arg_scope(
weight_decay=0.0001,
batch_norm_decay=0.997,
batch_norm_epsilon=1e-5,
batch_norm_scale=True,
activation_fn=tf.nn.relu,
use_batch_norm=True,
batch_norm_updates_collections=tf.compat.v1.GraphKeys.UPDATE_OPS):
"""Defines the default ResNet arg scope.
TODO(gpapan): The batch-normalization related default values above are
appropriate for use in conjunction with the reference ResNet models
released at https://github.com/KaimingHe/deep-residual-networks. When
training ResNets from scratch, they might need to be tuned.
Args:
weight_decay: The weight decay to use for regularizing the model.
batch_norm_decay: The moving average decay when estimating layer activation
statistics in batch normalization.
batch_norm_epsilon: Small constant to prevent division by zero when
normalizing activations by their variance in batch normalization.
batch_norm_scale: If True, uses an explicit `gamma` multiplier to scale the
activations in the batch normalization layer.
activation_fn: The activation function which is used in ResNet.
use_batch_norm: Whether or not to use batch normalization.
batch_norm_updates_collections: Collection for the update ops for
batch norm.
Returns:
An `arg_scope` to use for the resnet models.
"""
batch_norm_params = {
'decay': batch_norm_decay,
'epsilon': batch_norm_epsilon,
'scale': batch_norm_scale,
'updates_collections': batch_norm_updates_collections,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope(
[slim.conv2d],
weights_regularizer=slim.l2_regularizer(weight_decay),
weights_initializer=slim.variance_scaling_initializer(),
activation_fn=activation_fn,
normalizer_fn=slim.batch_norm if use_batch_norm else None,
normalizer_params=batch_norm_params):
with slim.arg_scope([slim.batch_norm], **batch_norm_params):
# The following implies padding='SAME' for pool1, which makes feature
# alignment easier for dense prediction tasks. This is also used in
# https://github.com/facebook/fb.resnet.torch. However the accompanying
# code of 'Deep Residual Learning for Image Recognition' uses
# padding='VALID' for pool1. You can switch to that choice by setting
# slim.arg_scope([slim.max_pool2d], padding='VALID').
with slim.arg_scope([slim.max_pool2d], padding='SAME') as arg_sc:
return arg_sc
| 42.755102 | 81 | 0.716786 |
ace022760100c885c9cb7927d5a9737ce43def2a | 402 | py | Python | packages/pycom/v1.18.2/esp32/stubs/websocket.py | TheVinhLuong102/micropy-stubs | 55ff1773008f7c4dfc3d70a403986486226eb6b3 | [
"MIT"
] | 18 | 2019-07-11T13:31:09.000Z | 2022-01-27T06:38:40.000Z | packages/pycom/v1.18.2/esp32/stubs/websocket.py | TheVinhLuong102/micropy-stubs | 55ff1773008f7c4dfc3d70a403986486226eb6b3 | [
"MIT"
] | 9 | 2019-09-01T21:44:49.000Z | 2022-02-04T20:55:08.000Z | packages/pycom/v1.18.2/esp32/stubs/websocket.py | TheVinhLuong102/micropy-stubs | 55ff1773008f7c4dfc3d70a403986486226eb6b3 | [
"MIT"
] | 6 | 2019-10-08T05:31:21.000Z | 2021-04-22T10:21:01.000Z | """
Module: 'websocket' on WiPy 07a52e4
"""
# MCU: (sysname='WiPy', nodename='WiPy', release='1.18.2', version='07a52e4-dirty on 2019-07-26', machine='WiPy with ESP32')
# Stubber: 1.2.0
class websocket:
''
def close():
pass
def ioctl():
pass
def read():
pass
def readinto():
pass
def readline():
pass
def write():
pass
| 14.888889 | 124 | 0.534826 |
ace0245b54c118a3eb5774f0f06a55f510a23bec | 8,102 | py | Python | keras2c/keras2c_main.py | matosjr/keras2c | 6787b9c485b1499cad21f981b64c0842c5362337 | [
"MIT"
] | 32 | 2019-08-07T18:37:09.000Z | 2022-03-31T00:28:19.000Z | keras2c/keras2c_main.py | matosjr/keras2c | 6787b9c485b1499cad21f981b64c0842c5362337 | [
"MIT"
] | 9 | 2019-06-29T17:23:10.000Z | 2022-03-25T01:04:50.000Z | keras2c/keras2c_main.py | matosjr/keras2c | 6787b9c485b1499cad21f981b64c0842c5362337 | [
"MIT"
] | 17 | 2019-06-29T17:21:20.000Z | 2022-03-28T08:10:37.000Z | """keras2c_main.py
This file is part of keras2c
Copyright 2020 Rory Conlin
Licensed under MIT License
https://github.com/f0uriest/keras2c
Converts keras model to C code
"""
# imports
from keras2c.layer2c import Layers2C
from keras2c.weights2c import Weights2C
from keras2c.io_parsing import layer_type, get_all_io_names, get_layer_io_names, \
get_model_io_names, flatten
from keras2c.check_model import check_model
from keras2c.make_test_suite import make_test_suite
import numpy as np
import subprocess
import tensorflow.keras as keras
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
__author__ = "Rory Conlin"
__copyright__ = "Copyright 2020, Rory Conlin"
__license__ = "MIT"
__maintainer__ = "Rory Conlin, https://github.com/f0uriest/keras2c"
__email__ = "wconlin@princeton.edu"
def model2c(model, function_name, malloc=False, verbose=True):
"""Generates C code for model
Writes main function definition to "function_name.c" and a public header
with declarations to "function_name.h"
Args:
model (keras Model): model to convert
function_name (str): name of C function
malloc (bool): whether to allocate variables on the stack or heap
verbose (bool): whether to print info to stdout
Returns:
malloc_vars (list): names of variables loaded at runtime and stored on the heap
stateful (bool): whether the model must maintain state between calls
"""
model_inputs, model_outputs = get_model_io_names(model)
includes = '#include <math.h> \n '
includes += '#include <string.h> \n'
includes += '#include "./include/k2c_include.h" \n'
includes += '#include "./include/k2c_tensor_include.h" \n'
includes += '\n \n'
if verbose:
print('Gathering Weights')
stack_vars, malloc_vars, static_vars = Weights2C(
model, function_name, malloc).write_weights(verbose)
stateful = len(static_vars) > 0
layers = Layers2C(model, malloc).write_layers(verbose)
function_signature = 'void ' + function_name + '('
function_signature += ', '.join(['k2c_tensor* ' +
in_nm + '_input' for in_nm in model_inputs]) + ', '
function_signature += ', '.join(['k2c_tensor* ' +
out_nm + '_output' for out_nm in model_outputs])
if len(malloc_vars.keys()):
function_signature += ',' + ','.join(['float* ' +
key for key in malloc_vars.keys()])
function_signature += ')'
init_sig, init_fun = gen_function_initialize(function_name, malloc_vars)
term_sig, term_fun = gen_function_terminate(function_name, malloc_vars)
reset_sig, reset_fun = gen_function_reset(function_name)
with open(function_name + '.c', 'x+') as source:
source.write(includes)
source.write(static_vars + '\n\n')
source.write(function_signature)
source.write(' { \n\n')
source.write(stack_vars)
source.write(layers)
source.write('\n } \n\n')
source.write(init_fun)
source.write(term_fun)
if stateful:
source.write(reset_fun)
with open(function_name + '.h', 'x+') as header:
header.write('#pragma once \n')
header.write('#include "./include/k2c_tensor_include.h" \n')
header.write(function_signature + '; \n')
header.write(init_sig + '; \n')
header.write(term_sig + '; \n')
if stateful:
header.write(reset_sig + '; \n')
try:
subprocess.run(['astyle', '-n', function_name + '.h'])
subprocess.run(['astyle', '-n', function_name + '.c'])
except FileNotFoundError:
print("astyle not found, {} and {} will not be auto-formatted".format(function_name + ".h", function_name + ".c"))
return malloc_vars.keys(), stateful
def gen_function_reset(function_name):
"""Writes a reset function for stateful models
Reset function is used to clear internal state of the model
Args:
function_name (str): name of main function
Returns:
signature (str): delcaration of the reset function
function (str): definition of the reset function
"""
reset_sig = 'void ' + function_name + '_reset_states()'
reset_fun = reset_sig
reset_fun += ' { \n\n'
reset_fun += 'memset(&' + function_name + \
'_states,0,sizeof(' + function_name + '_states)); \n'
reset_fun += "} \n\n"
return reset_sig, reset_fun
def gen_function_initialize(function_name, malloc_vars):
"""Writes an initialize function
Initialize function is used to load variables into memory and do other start up tasks
Args:
function_name (str): name of main function
malloc_vars (dict): variables to read in
Returns:
signature (str): delcaration of the initialization function
function (str): definition of the initialization function
"""
init_sig = 'void ' + function_name + '_initialize('
init_sig += ','.join(['float** ' +
key + ' \n' for key in malloc_vars.keys()])
init_sig += ')'
init_fun = init_sig
init_fun += ' { \n\n'
for key in malloc_vars.keys():
fname = function_name + key + ".csv"
np.savetxt(fname, malloc_vars[key], fmt="%.8e", delimiter=',')
init_fun += '*' + key + " = k2c_read_array(\"" + \
fname + "\"," + str(malloc_vars[key].size) + "); \n"
init_fun += "} \n\n"
return init_sig, init_fun
def gen_function_terminate(function_name, malloc_vars):
"""Writes a terminate function
Terminate function is used to deallocate memory after completion
Args:
function_name (str): name of main function
malloc_vars (dict): variables to deallocate
Returns:
signature (str): delcaration of the terminate function
function (str): definition of the terminate function
"""
term_sig = 'void ' + function_name + '_terminate('
term_sig += ','.join(['float* ' +
key for key in malloc_vars.keys()])
term_sig += ')'
term_fun = term_sig
term_fun += ' { \n\n'
for key in malloc_vars.keys():
term_fun += "free(" + key + "); \n"
term_fun += "} \n\n"
return term_sig, term_fun
def k2c(model, function_name, malloc=False, num_tests=10, verbose=True):
"""Converts keras model to C code and generates test suite
Args:
model (keras Model or str): model to convert or path to saved .h5 file
function_name (str): name of main function
malloc (bool): whether to allocate variables on the stack or heap
num_tests (int): how many tests to generate in the test suite
verbose (bool): whether to print progress
Raises:
ValueError: if model is not instance of keras.models.Model
Returns:
None
"""
function_name = str(function_name)
filename = function_name + '.c'
if isinstance(model, str):
model = keras.models.load_model(model, compile=False)
elif not isinstance(model, keras.models.Model):
raise ValueError('Unknown model type. Model should ' +
'either be an instance of keras.models.Model, ' +
'or a filepath to a saved .h5 model')
# check that the model can be converted
check_model(model, function_name)
if verbose:
print('All checks passed')
malloc_vars, stateful = model2c(
model, function_name, malloc, verbose)
s = 'Done \n'
s += "C code is in '" + function_name + \
".c' with header file '" + function_name + ".h' \n"
if num_tests > 0:
make_test_suite(model, function_name, malloc_vars,
num_tests, stateful, verbose)
s += "Tests are in '" + function_name + "_test_suite.c' \n"
if malloc:
s += "Weight arrays are in .csv files of the form 'model_name_layer_name_array_type.csv' \n"
s += "They should be placed in the directory from which the main program is run."
if verbose:
print(s)
| 34.476596 | 122 | 0.63651 |
ace025fe4bfc4a040067f97b82940bd2931fe3d5 | 3,544 | py | Python | playbooks/files/rax-maas/plugins/neutron_service_check.py | mvollman/rpc-maas | a233dadb293572369a9fdad1c0c7aff075ef45f2 | [
"Apache-2.0"
] | null | null | null | playbooks/files/rax-maas/plugins/neutron_service_check.py | mvollman/rpc-maas | a233dadb293572369a9fdad1c0c7aff075ef45f2 | [
"Apache-2.0"
] | null | null | null | playbooks/files/rax-maas/plugins/neutron_service_check.py | mvollman/rpc-maas | a233dadb293572369a9fdad1c0c7aff075ef45f2 | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/env python
# Copyright 2014, Rackspace US, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
from maas_common import get_neutron_client
from maas_common import metric_bool
from maas_common import print_output
from maas_common import status_err
from maas_common import status_ok
def check(args):
NETWORK_ENDPOINT = '{protocol}://{hostname}:9696'.format(
protocol=args.protocol, hostname=args.hostname)
try:
neutron = get_neutron_client(endpoint_url=NETWORK_ENDPOINT)
# not gathering api status metric here so catch any exception
except Exception as e:
metric_bool('client_success', False, m_name='maas_neutron')
status_err(str(e), m_name='maas_neutron')
else:
metric_bool('client_success', True, m_name='maas_neutron')
# gather neutron service states
if args.host:
agents = neutron.list_agents(host=args.host)['agents']
elif args.fqdn:
agents = neutron.list_agents(host=args.fqdn)['agents']
else:
agents = neutron.list_agents()['agents']
if len(agents) == 0:
metric_bool('agents_found', False, m_name='maas_neutron')
status_err("No host(s) found in the agents list",
m_name='maas_neutron')
else:
metric_bool('agents_found', True, m_name='maas_neutron')
# return all the things
status_ok(m_name='maas_neutron')
for agent in agents:
agent_is_up = True
if agent['admin_state_up'] and not agent['alive']:
agent_is_up = False
if args.host:
name = '%s_status' % agent['binary']
elif args.fqdn:
name = '%z_status' % agent['binary']
else:
name = '%s_%s_on_host_%s' % (agent['binary'],
agent['id'],
agent['host'])
metric_bool(name, agent_is_up, m_name='maas_neutron')
def main(args):
check(args)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Check neutron agents')
parser.add_argument('hostname',
type=str,
help='Neutron API hostname or IP address')
parser.add_argument('--host',
type=str,
help='Only return metrics for specified host',
default=None)
parser.add_argument('--fqdn',
type=str,
help='Only return metrics for specified fqdn',
default=None)
parser.add_argument('--telegraf-output',
action='store_true',
default=False,
help='Set the output format to telegraf')
parser.add_argument('--protocol',
type=str,
default='http',
help='Protocol for client requests')
args = parser.parse_args()
with print_output(print_telegraf=args.telegraf_output):
main(args)
| 34.745098 | 74 | 0.609481 |
ace0267becfd625fce4062eecb25fd999f987a86 | 737 | py | Python | package/cipherpy/base/alphabet.py | mondas-mania/cipher-py | e1dd287311ab487fd54a8becee444b3d7561b63c | [
"MIT"
] | null | null | null | package/cipherpy/base/alphabet.py | mondas-mania/cipher-py | e1dd287311ab487fd54a8becee444b3d7561b63c | [
"MIT"
] | null | null | null | package/cipherpy/base/alphabet.py | mondas-mania/cipher-py | e1dd287311ab487fd54a8becee444b3d7561b63c | [
"MIT"
] | null | null | null | import string
# Create a keyed alphabet
def keyed_alphabet(alphabet_key, alphabet=string.ascii_lowercase):
non_chars = [char for char in alphabet_key if char not in alphabet]
if non_chars:
raise Exception(f"{non_chars} in the key cannot be found in the given alphabet.")
new_alphabet = alphabet
new_alphabet_key = ''.join(sorted(set(alphabet_key), key=alphabet_key.index))
for char in new_alphabet_key:
new_alphabet = new_alphabet.replace(char, '')
new_alphabet = new_alphabet_key + new_alphabet
return new_alphabet
# Invert the alphabet
# It's a basic string comprehension but nice to give it a name
def invert_alphabet(alphabet=string.ascii_lowercase):
return alphabet[::-1] | 35.095238 | 89 | 0.736771 |
ace029e21c580e69071df55677ae37b750d95ca7 | 12,648 | py | Python | ironic/tests/unit/drivers/modules/oneview/test_vendor.py | ericxiett/ironic-customized | 3a2ad13969e1497889a0c3be80f9f5f671ff4d1b | [
"Apache-2.0"
] | null | null | null | ironic/tests/unit/drivers/modules/oneview/test_vendor.py | ericxiett/ironic-customized | 3a2ad13969e1497889a0c3be80f9f5f671ff4d1b | [
"Apache-2.0"
] | null | null | null | ironic/tests/unit/drivers/modules/oneview/test_vendor.py | ericxiett/ironic-customized | 3a2ad13969e1497889a0c3be80f9f5f671ff4d1b | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
#
# Copyright 2015 Red Hat, Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import time
import types
import mock
from ironic.common import exception
from ironic.common import states
from ironic.conductor import task_manager
from ironic.conductor import utils as manager_utils
from ironic.drivers.modules import agent_client
from ironic.drivers.modules.oneview import power
from ironic.drivers.modules.oneview import vendor
from ironic.drivers.modules import pxe
from ironic.drivers import utils as driver_utils
from ironic.tests.unit.conductor import mgr_utils
from ironic.tests.unit.db import base as db_base
from ironic.tests.unit.db import utils as db_utils
from ironic.tests.unit.objects import utils as obj_utils
GET_POWER_STATE_RETRIES = 5
class TestBaseAgentVendor(db_base.DbTestCase):
def setUp(self):
super(TestBaseAgentVendor, self).setUp()
self.config(
post_deploy_get_power_state_retries=GET_POWER_STATE_RETRIES,
group='agent')
mgr_utils.mock_the_extension_manager(driver="agent_pxe_oneview")
self.passthru = vendor.AgentVendorInterface()
self.node = obj_utils.create_test_node(
self.context, driver='agent_pxe_oneview',
properties=db_utils.get_test_oneview_properties(),
driver_info=db_utils.get_test_oneview_driver_info(),
)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
@mock.patch('ironic.conductor.utils.node_set_boot_device', autospec=True)
def test_reboot_and_finish_deploy(self, set_bootdev_mock, power_off_mock,
get_power_state_mock,
node_power_action_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.side_effect = [states.POWER_ON,
states.POWER_OFF]
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(2, get_power_state_mock.call_count)
set_bootdev_mock.assert_called_once_with(task, 'disk',
persistent=True)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_soft_poweroff_doesnt_complete(
self, power_off_mock, get_power_state_mock,
node_power_action_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_ON
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(GET_POWER_STATE_RETRIES + 1,
get_power_state_mock.call_count)
node_power_action_mock.assert_has_calls([
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_ON)
])
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_soft_poweroff_fails(
self, power_off_mock, node_power_action_mock):
power_off_mock.side_effect = RuntimeError("boom")
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
node_power_action_mock.assert_has_calls([
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_ON)
])
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_get_power_state_fails(
self, power_off_mock, get_power_state_mock,
node_power_action_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.side_effect = RuntimeError("boom")
self.passthru.reboot_and_finish_deploy(task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(GET_POWER_STATE_RETRIES + 1,
get_power_state_mock.call_count)
node_power_action_mock.assert_has_calls([
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_ON)
])
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_power_action_fails(
self, power_off_mock, get_power_state_mock,
node_power_action_mock, collect_ramdisk_logs_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_ON
node_power_action_mock.side_effect = RuntimeError("boom")
self.assertRaises(exception.InstanceDeployFailure,
self.passthru.reboot_and_finish_deploy,
task)
power_off_mock.assert_called_once_with(task.node)
self.assertEqual(GET_POWER_STATE_RETRIES + 1,
get_power_state_mock.call_count)
node_power_action_mock.assert_has_calls([
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_OFF)])
self.assertEqual(states.DEPLOYFAIL, task.node.provision_state)
self.assertEqual(states.ACTIVE, task.node.target_provision_state)
collect_ramdisk_logs_mock.assert_called_once_with(task.node)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
@mock.patch('ironic.drivers.modules.agent.AgentVendorInterface'
'.check_deploy_success', autospec=True)
@mock.patch.object(pxe.PXEBoot, 'clean_up_ramdisk', autospec=True)
def test_reboot_to_instance(self, clean_pxe_mock, check_deploy_mock,
power_off_mock, get_power_state_mock,
node_power_action_mock):
check_deploy_mock.return_value = None
self.node.provision_state = states.DEPLOYWAIT
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_OFF
task.node.driver_internal_info['is_whole_disk_image'] = True
self.passthru.reboot_to_instance(task)
clean_pxe_mock.assert_called_once_with(task.driver.boot, task)
check_deploy_mock.assert_called_once_with(mock.ANY, task.node)
power_off_mock.assert_called_once_with(task.node)
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(power.OneViewPower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
spec=types.FunctionType)
@mock.patch('ironic.drivers.modules.agent.AgentVendorInterface'
'.check_deploy_success', autospec=True)
@mock.patch.object(pxe.PXEBoot, 'clean_up_ramdisk', autospec=True)
def test_reboot_to_instance_boot_none(self, clean_pxe_mock,
check_deploy_mock,
power_off_mock,
get_power_state_mock,
node_power_action_mock):
check_deploy_mock.return_value = None
self.node.provision_state = states.DEPLOYWAIT
self.node.target_provision_state = states.ACTIVE
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_OFF
task.node.driver_internal_info['is_whole_disk_image'] = True
task.driver.boot = None
self.passthru.reboot_to_instance(task)
self.assertFalse(clean_pxe_mock.called)
check_deploy_mock.assert_called_once_with(mock.ANY, task.node)
power_off_mock.assert_called_once_with(task.node)
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
| 50.190476 | 78 | 0.662397 |
ace02ae441636fff166434623e956b7cd8a54853 | 7,609 | py | Python | tests/json_tests.py | donatosaur/marble-game | dcbc636489a21486c112d2105db8b188a81d1a5f | [
"Apache-2.0"
] | 2 | 2021-09-03T17:20:48.000Z | 2021-09-25T14:56:58.000Z | tests/json_tests.py | donatosaur/marble-game | dcbc636489a21486c112d2105db8b188a81d1a5f | [
"Apache-2.0"
] | null | null | null | tests/json_tests.py | donatosaur/marble-game | dcbc636489a21486c112d2105db8b188a81d1a5f | [
"Apache-2.0"
] | null | null | null | # Modified: 2021-08-22
# Description: Contains unit tests for JSON Encoding & Decoding of package objects
import unittest
import json
from marble_game.marble_game import MarbleGame, MarbleGameEncoder, MarbleGameDecoder
from marble_game.game_board import GameBoard, GameBoardEncoder, GameBoardDecoder
class GameBoardJSONTests(unittest.TestCase):
"""Contains unit tests for GameBoard JSON encoding & decoding"""
def setUp(self):
"""Create GameBoards and JSON strings to be used in tests"""
self._initial_board = GameBoard()
self._board = GameBoard()
self._board.move_marble((0, 5), 'F') # the black marble at 0, 5 should be removed from the board
self._board.move_marble((2, 4), 'F') # the red marble at 0, 4 should now be at 1, 4
self.json_string_init = json.dumps(
{
"grid": "WW BBWW R BB RRR RRRRR RRR BB R WWBB WW",
"previous_state": " "*49,
},
sort_keys=True,
)
self.json_string_mid = json.dumps(
{
"grid": "WW BWW RRBB RR RRRRR RRR BB R WWBB WW",
"previous_state": "WW BWW R BB RRR RRRRR RRR BB R WWBB WW",
},
sort_keys=True,
)
def test_encode(self):
"""Tests whether GameBoard is encoded as expected"""
# test encoding the board in its initial state
self.assertEqual(self.json_string_init, json.dumps(self._initial_board, cls=GameBoardEncoder, sort_keys=True))
# test encoding the board after two moves are made
self.assertEqual(self.json_string_mid, json.dumps(self._board, cls=GameBoardEncoder, sort_keys=True))
def test_decode(self):
"""Tests whether GameBoard is decoded as expected"""
# decode the string
board = json.loads(self.json_string_mid, cls=GameBoardDecoder)
# check whether an instance of GameBoard was returned
self.assertIsInstance(board, GameBoard)
# check whether the grid and previous states are set as expected
self.assertEqual("WW BWW RRBB RR RRRRR RRR BB R WWBB WW", board.grid_as_str)
self.assertEqual("WW BWW R BB RRR RRRRR RRR BB R WWBB WW", board.previous_grid_as_str)
def test_encode_then_decode(self):
"""Tests whether GameBoard can be encoded then decoded to the same state"""
encoded_json = json.dumps(self._board, cls=GameBoardEncoder)
decoded_board = json.loads(encoded_json, cls=GameBoardDecoder)
for var in vars(self._board):
self.assertEqual(getattr(self._board, var), getattr(decoded_board, var))
class MarbleGameJSONTests(unittest.TestCase):
"""Contains unit tests for MarbleGame JSON encoding & decoding"""
def setUp(self):
"""Create a MarbleGame and JSON strings to be used in tests"""
self._player_b = "Player B ID"
self._player_w = "Player W ID"
self._test_game = MarbleGame((self._player_b, 'B'), (self._player_w, 'W'))
self.json_string_init = json.dumps(
{
"board": json.dumps({
"grid": "WW BBWW R BB RRR RRRRR RRR BB R WWBB WW",
"previous_state": " " * 49,
}),
"players": json.dumps({
"Player B ID": {
"color": 'B',
"red_marbles_captured": 0,
"opponent_marbles_captured": 0,
},
"Player W ID":
{
"color": 'W',
"red_marbles_captured": 0,
"opponent_marbles_captured": 0,
},
},
),
"current_turn": None,
"winner": None,
},
sort_keys=True,
)
self.json_string_mid = json.dumps(
{
"board": json.dumps({
"grid": " W BBWW R BBW RRR RRRRR RRR BB R WWBB WW",
"previous_state": "WW BBWW R BB RRR RRRRR RRR BB R WWBB WW",
}),
"players": json.dumps({
"Player B ID": {
"color": 'B',
"red_marbles_captured": 0,
"opponent_marbles_captured": 0,
},
"Player W ID":
{
"color": 'W',
"red_marbles_captured": 0,
"opponent_marbles_captured": 0,
},
},
),
"current_turn": "Player B ID",
"winner": None,
},
sort_keys=True,
)
def test_encode(self):
"""Tests whether MarbleGame is encoded as expected"""
# test encoding the game in its initial state
self.assertEqual(self.json_string_init, json.dumps(self._test_game, cls=MarbleGameEncoder, sort_keys=True))
# test encoding after the first move has taken place
self._test_game.make_move("Player W ID", (0, 0), 'B')
self.assertEqual(self.json_string_mid, json.dumps(self._test_game, cls=MarbleGameEncoder, sort_keys=True))
def test_decode(self):
"""Tests whether MarbleGame is decoded as expected"""
# decode the string
game = json.loads(self.json_string_mid, cls=MarbleGameDecoder)
# check whether an instance of MarbleGame was returned
self.assertIsInstance(game, MarbleGame)
# check whether the board state is set as expected
self.assertEqual(" W BBWW R BBW RRR RRRRR RRR BB R WWBB WW", game._game_board.grid_as_str)
self.assertEqual("WW BBWW R BB RRR RRRRR RRR BB R WWBB WW", game._game_board.previous_grid_as_str)
# check whether the game state is set as expected
players_expected = {
"Player B ID":
{
"color": 'B',
"opponent_marbles_captured": 0,
"red_marbles_captured": 0,
},
"Player W ID":
{
"color": 'W',
"opponent_marbles_captured": 0,
"red_marbles_captured": 0,
}
}
self.assertDictEqual(players_expected, game._players)
self.assertEqual("Player B ID", game.current_turn)
self.assertIsNone(game.winner)
def test_encode_then_decode(self):
"""Tests whether MarbleGame can be encoded then decoded to the same state"""
encoded_json = json.dumps(self._test_game, cls=MarbleGameEncoder)
decoded_game = json.loads(encoded_json, cls=MarbleGameDecoder)
for var in vars(self._test_game):
if var == "_game_board":
# GameBoard doesn't have __eq__ defined, so we need to compare its properties individually
original_board = self._test_game._game_board
decoded_board = decoded_game._game_board
for board_var in vars(self._test_game._game_board):
self.assertEqual(getattr(original_board, board_var), getattr(decoded_board, board_var))
else:
self.assertEqual(getattr(self._test_game, var), getattr(decoded_game, var))
if __name__ == '__main__':
unittest.main()
| 42.50838 | 118 | 0.551846 |
ace02b22478c6dbad2ddc6f009769372ef53f8ad | 3,484 | py | Python | hyper_internal_service/hdrs.py | intellivoid/Hyper-Internal-Service | 16a13fe0a10a12007d286d7f30d7b72dab81d73f | [
"Unlicense"
] | null | null | null | hyper_internal_service/hdrs.py | intellivoid/Hyper-Internal-Service | 16a13fe0a10a12007d286d7f30d7b72dab81d73f | [
"Unlicense"
] | null | null | null | hyper_internal_service/hdrs.py | intellivoid/Hyper-Internal-Service | 16a13fe0a10a12007d286d7f30d7b72dab81d73f | [
"Unlicense"
] | null | null | null | """HTTP Headers constants."""
# After changing the file content call ./tools/gen.py
# to regenerate the headers parser
from multidict import istr
METH_ANY = '*'
METH_CONNECT = 'CONNECT'
METH_HEAD = 'HEAD'
METH_GET = 'GET'
METH_DELETE = 'DELETE'
METH_OPTIONS = 'OPTIONS'
METH_PATCH = 'PATCH'
METH_POST = 'POST'
METH_PUT = 'PUT'
METH_TRACE = 'TRACE'
METH_ALL = {METH_CONNECT, METH_HEAD, METH_GET, METH_DELETE,
METH_OPTIONS, METH_PATCH, METH_POST, METH_PUT, METH_TRACE}
ACCEPT = istr('Accept')
ACCEPT_CHARSET = istr('Accept-Charset')
ACCEPT_ENCODING = istr('Accept-Encoding')
ACCEPT_LANGUAGE = istr('Accept-Language')
ACCEPT_RANGES = istr('Accept-Ranges')
ACCESS_CONTROL_MAX_AGE = istr('Access-Control-Max-Age')
ACCESS_CONTROL_ALLOW_CREDENTIALS = istr('Access-Control-Allow-Credentials')
ACCESS_CONTROL_ALLOW_HEADERS = istr('Access-Control-Allow-Headers')
ACCESS_CONTROL_ALLOW_METHODS = istr('Access-Control-Allow-Methods')
ACCESS_CONTROL_ALLOW_ORIGIN = istr('Access-Control-Allow-Origin')
ACCESS_CONTROL_EXPOSE_HEADERS = istr('Access-Control-Expose-Headers')
ACCESS_CONTROL_REQUEST_HEADERS = istr('Access-Control-Request-Headers')
ACCESS_CONTROL_REQUEST_METHOD = istr('Access-Control-Request-Method')
AGE = istr('Age')
ALLOW = istr('Allow')
AUTHORIZATION = istr('Authorization')
CACHE_CONTROL = istr('Cache-Control')
CONNECTION = istr('Connection')
CONTENT_DISPOSITION = istr('Content-Disposition')
CONTENT_ENCODING = istr('Content-Encoding')
CONTENT_LANGUAGE = istr('Content-Language')
CONTENT_LENGTH = istr('Content-Length')
CONTENT_LOCATION = istr('Content-Location')
CONTENT_MD5 = istr('Content-MD5')
CONTENT_RANGE = istr('Content-Range')
CONTENT_TRANSFER_ENCODING = istr('Content-Transfer-Encoding')
CONTENT_TYPE = istr('Content-Type')
COOKIE = istr('Cookie')
DATE = istr('Date')
DESTINATION = istr('Destination')
DIGEST = istr('Digest')
ETAG = istr('Etag')
EXPECT = istr('Expect')
EXPIRES = istr('Expires')
FORWARDED = istr('Forwarded')
FROM = istr('From')
HOST = istr('Host')
IF_MATCH = istr('If-Match')
IF_MODIFIED_SINCE = istr('If-Modified-Since')
IF_NONE_MATCH = istr('If-None-Match')
IF_RANGE = istr('If-Range')
IF_UNMODIFIED_SINCE = istr('If-Unmodified-Since')
KEEP_ALIVE = istr('Keep-Alive')
LAST_EVENT_ID = istr('Last-Event-ID')
LAST_MODIFIED = istr('Last-Modified')
LINK = istr('Link')
LOCATION = istr('Location')
MAX_FORWARDS = istr('Max-Forwards')
ORIGIN = istr('Origin')
PRAGMA = istr('Pragma')
PROXY_AUTHENTICATE = istr('Proxy-Authenticate')
PROXY_AUTHORIZATION = istr('Proxy-Authorization')
RANGE = istr('Range')
REFERER = istr('Referer')
RETRY_AFTER = istr('Retry-After')
SEC_WEBSOCKET_ACCEPT = istr('Sec-WebSocket-Accept')
SEC_WEBSOCKET_VERSION = istr('Sec-WebSocket-Version')
SEC_WEBSOCKET_PROTOCOL = istr('Sec-WebSocket-Protocol')
SEC_WEBSOCKET_EXTENSIONS = istr('Sec-WebSocket-Extensions')
SEC_WEBSOCKET_KEY = istr('Sec-WebSocket-Key')
SEC_WEBSOCKET_KEY1 = istr('Sec-WebSocket-Key1')
SERVER = istr('Server')
SET_COOKIE = istr('Set-Cookie')
TE = istr('TE')
TRAILER = istr('Trailer')
TRANSFER_ENCODING = istr('Transfer-Encoding')
UPGRADE = istr('Upgrade')
WEBSOCKET = istr('WebSocket')
URI = istr('URI')
USER_AGENT = istr('User-Agent')
VARY = istr('Vary')
VIA = istr('Via')
WANT_DIGEST = istr('Want-Digest')
WARNING = istr('Warning')
WWW_AUTHENTICATE = istr('WWW-Authenticate')
X_POWERED_BY = istr('X-Powered-By')
X_FORWARDED_FOR = istr('X-Forwarded-For')
X_FORWARDED_HOST = istr('X-Forwarded-Host')
X_FORWARDED_PROTO = istr('X-Forwarded-Proto') | 34.49505 | 75 | 0.757176 |
ace02c4f634c5b5ca0d0941de657e157570b275f | 1,152 | py | Python | setup.py | victorhaggqvist/sphinxcontrib-phpdomain | b0bb142f9a3203bd808901e032b0c822b9e54d83 | [
"BSD-2-Clause"
] | null | null | null | setup.py | victorhaggqvist/sphinxcontrib-phpdomain | b0bb142f9a3203bd808901e032b0c822b9e54d83 | [
"BSD-2-Clause"
] | null | null | null | setup.py | victorhaggqvist/sphinxcontrib-phpdomain | b0bb142f9a3203bd808901e032b0c822b9e54d83 | [
"BSD-2-Clause"
] | null | null | null | # -*- coding: utf-8 -*-
from setuptools import setup, find_packages
long_desc = '''
This package contains the phpdomain Sphinx extension.
This extension provides a PHP domain for sphinx
'''
requires = ['Sphinx>=1.0']
setup(
name='sphinxcontrib-phpdomain',
version='0.1.5',
url='http://bitbucket.org/markstory/sphinx-contrib',
download_url='http://pypi.python.org/pypi/sphinxcontrib-phpdomain',
license='BSD',
author='Mark Story',
author_email='mark at mark-story dot com',
description='Sphinx "phpdomain" extension',
long_description=long_desc,
zip_safe=False,
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Documentation',
'Topic :: Utilities',
],
platforms='any',
packages=find_packages(),
include_package_data=True,
install_requires=requires,
namespace_packages=['sphinxcontrib'],
)
| 27.428571 | 71 | 0.654514 |
ace02d2bd5bd324abd90b7c83ec17a427c84851b | 13,311 | py | Python | fanficfare/mobi.py | Hypernoc/FanFicFare | 869ed37137c82cd71ec589f36bc2001528d5e76c | [
"Apache-2.0"
] | 1 | 2020-03-26T05:44:01.000Z | 2020-03-26T05:44:01.000Z | fanficfare/mobi.py | Hypernoc/FanFicFare | 869ed37137c82cd71ec589f36bc2001528d5e76c | [
"Apache-2.0"
] | null | null | null | fanficfare/mobi.py | Hypernoc/FanFicFare | 869ed37137c82cd71ec589f36bc2001528d5e76c | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright(c) 2009 Andrew Chatham and Vijay Pandurangan
# Changes Copyright 2018 FanFicFare team
from __future__ import absolute_import
import struct
import time
import random
import logging
# py2 vs py3 transition
from .six import text_type as unicode
from .six import string_types as basestring
from .six import ensure_binary
from io import BytesIO
logger = logging.getLogger(__name__)
from .mobihtml import HtmlProcessor
# http://wiki.mobileread.com/wiki/MOBI
# http://membres.lycos.fr/microfirst/palm/pdb.html
encoding = {
'UTF-8' : 65001,
'latin-1' : 1252,
}
languages = {"en-us" : 0x0409,
"sv" : 0x041d,
"fi" : 0x000b,
"en" : 0x0009,
"en-gb" : 0x0809}
def ToHex(s):
v = ['%.2x' % ord(c) for c in s]
return ' '.join(v)
class _SubEntry:
def __init__(self, pos, html_data):
self.pos = pos
self.html = HtmlProcessor(html_data)
self.title = self.html.title
self._name = 'mobi_article_%d' % pos
if not self.title:
self.title = 'Article %d' % self.pos
def TocLink(self):
return '<a href="#%s_MOBI_START">%.80s</a>' % (self._name, self.title)
def Anchor(self):
return '<a name="%s_MOBI_START">' % self._name
def Body(self):
return self.html.RenameAnchors(self._name + '_')
class Converter:
def __init__(self, refresh_url='', title='Unknown', author='Unknown', publisher='Unknown'):
self._header = Header()
self._header.SetTitle(title)
self._header.SetAuthor(author)
self._header.SetPublisher(publisher)
self._refresh_url = refresh_url
def ConvertString(self, s):
out = BytesIO()
self._ConvertStringToFile(s, out)
return out.getvalue()
def ConvertStrings(self, html_strs):
out = BytesIO()
self._ConvertStringsToFile(html_strs, out)
return out.getvalue()
def ConvertFile(self, html_file, out_file):
self._ConvertStringToFile(open(html_file,'rb').read(),
open(out_file, 'wb'))
def ConvertFiles(self, html_files, out_file):
html_strs = [open(f,'rb').read() for f in html_files]
self._ConvertStringsToFile(html_strs, open(out_file, 'wb'))
def MakeOneHTML(self, html_strs):
"""This takes a list of HTML strings and returns a big HTML file with
all contents consolidated. It constructs a table of contents and adds
anchors within the text
"""
title_html = []
toc_html = []
body_html = []
## This gets broken by html5lib/bs4fixed being helpful, but we'll
## fix it inside mobihtml.py
PAGE_BREAK = '<mbp:pagebreak/>'
# pull out the title page, assumed first html_strs.
htmltitle = html_strs[0]
entrytitle = _SubEntry(1, htmltitle)
title_html.append(entrytitle.Body())
title_html.append(PAGE_BREAK)
toc_html.append(PAGE_BREAK)
toc_html.append('<a name="TOCTOP"><h3>Table of Contents</h3><br />')
for pos, html in enumerate(html_strs[1:]):
entry = _SubEntry(pos+1, html)
toc_html.append('%s<br />' % entry.TocLink())
# give some space between bodies of work.
body_html.append(PAGE_BREAK)
body_html.append(entry.Anchor())
body_html.append(entry.Body())
# TODO: this title can get way too long with RSS feeds. Not sure how to fix
# cheat slightly and use the <a href> code to set filepos in references.
header = '''<html>
<head>
<title>Bibliorize %s GMT</title>
<guide>
<reference href="#TOCTOP" type="toc" title="Table of Contents"/>
</guide>
</head>
<body>
''' % time.ctime(time.time())
footer = '</body></html>'
# logger.debug("header:%s"%header)
# logger.debug("title_html:%s"%title_html)
# logger.debug("toc_html:%s"%toc_html)
# logger.debug("body_html:%s"%body_html)
# logger.debug("footer:%s"%footer)
all_html = header + '\n'.join(title_html + toc_html + body_html) + footer
#print "%s" % all_html.encode('utf8')
return all_html
def _ConvertStringsToFile(self, html_strs, out_file):
try:
tmp = self.MakeOneHTML(html_strs)
self._ConvertStringToFile(tmp, out_file)
except Exception as e:
raise
logger.error('Error %s', e)
# logger.debug('Details: %s' % html_strs)
def _ConvertStringToFile(self, html_data, out):
html = HtmlProcessor(html_data)
data = ensure_binary(html.CleanHtml())
# collect offsets of '<mbp:pagebreak>' tags, use to make index list.
# indexlist = [] # list of (offset,length) tuples.
# not in current use.
# j=0
# lastj=0
# while True:
# j=data.find('<mbp:pagebreak>',lastj+10) # plus a bit so we find the next.
# if j < 0:
# break
# indexlist.append((lastj,j-lastj))
# print "index offset: %d length: %d" % (lastj,j-lastj)
# lastj=j
records = []
# title = html.title
# if title:
# self._header.SetTitle(title)
record_id = 1
# logger.debug("len(data):%s"%len(data))
for start_pos in range(0, len(data), Record.MAX_SIZE):
end = min(len(data), start_pos + Record.MAX_SIZE)
record_data = data[start_pos:end]
records.append(self._header.AddRecord(record_data, record_id))
# logger.debug("HTML Record %03d: (size:%d) [[%s ... %s]]" % ( record_id, len(record_data), record_data[:20], record_data[-20:] ))
record_id += 1
self._header.SetImageRecordIndex(record_id)
records[0:0] = [self._header.MobiHeader()]
header, rec_offset = self._header.PDBHeader(len(records))
out.write(ensure_binary(header))
for record in records:
record.WriteHeader(out, rec_offset)
# logger.debug("rec_offset: %d len(record.data): %d" % (rec_offset,len(record.data)))
rec_offset += (len(record.data)+1) # plus one for trailing null
# Write to nuls for some reason
out.write(b'\0\0')
for record in records:
record.WriteData(out)
out.write(b'\0')
# needs a trailing null, I believe it indicates zero length 'overlap'.
# otherwise, the readers eat the last char of each html record.
# Calibre writes another 6-7 bytes of stuff after that, but we seem
# to be getting along without it.
class Record:
MAX_SIZE = 4096
INDEX_LEN = 8
_unique_id_seed = 28 # should be arbitrary, but taken from MobiHeader
# TODO(chatham): Record compression doesn't look that hard.
def __init__(self, data, record_id):
assert len(data) <= self.MAX_SIZE
self.data = data
if record_id != 0:
self._id = record_id
else:
Record._unique_id_seed += 1
self._id = 0
def __repr__(self):
return 'Record: id=%d len=%d' % (self._id, len(self.data))
def _SetUniqueId(self):
Record._unique_id_seed += 1
# TODO(chatham): Wraparound crap
self._id = Record._unique_id_seed
def WriteData(self, out):
out.write(ensure_binary(self.data))
def WriteHeader(self, out, rec_offset):
attributes = 64 # dirty?
header = struct.pack('>IbbH',
rec_offset,
attributes,
0, self._id)
assert len(header) == Record.INDEX_LEN
out.write(ensure_binary(header))
EXTH_HEADER_FIELDS = {
'author' : 100,
'publisher' : 101,
}
class Header:
EPOCH_1904 = 2082844800
def __init__(self):
self._length = 0
self._record_count = 0
self._title = '2008_2_34'
self._author = 'Unknown author'
self._publisher = 'Unknown publisher'
self._first_image_index = 0
def SetAuthor(self, author):
self._author = author.encode('ascii','ignore')
def SetTitle(self, title):
# TODO(chatham): Reevaluate whether this needs to be ASCII.
# maybe just do sys.setdefaultencoding('utf-8')? Problems
# appending self._title with other things.
self._title = title.encode('ascii','ignore')
def SetPublisher(self, publisher):
self._publisher = publisher.encode('ascii','ignore')
def AddRecord(self, data, record_id):
self.max_record_size = max(Record.MAX_SIZE, len(data))
self._record_count += 1
# logger.debug("len(data):%s"%len(data))
self._length += len(data)
return Record(data, record_id)
def _ReplaceWord(self, data, pos, word):
return data[:pos] + struct.pack('>I', word) + data[pos+4:]
def PalmDocHeader(self):
compression = 1 # no compression
unused = 0
encryption_type = 0 # no ecryption
records = self._record_count + 1 # the header record itself
palmdoc_header = struct.pack('>HHIHHHH',
compression,
unused,
self._length,
records,
Record.MAX_SIZE,
encryption_type,
unused)
assert len(palmdoc_header) == 16
return palmdoc_header
def PDBHeader(self, num_records):
# logger.debug("num_records:%s"%num_records)
HEADER_LEN = 32+2+2+9*4
RECORD_INDEX_HEADER_LEN = 6
RESOURCE_INDEX_LEN = 10
index_len = RECORD_INDEX_HEADER_LEN + num_records * Record.INDEX_LEN
rec_offset = HEADER_LEN + index_len + 2
# logger.debug("index_len:%s"%index_len)
# logger.debug("rec_offset:%s"%rec_offset)
short_title = self._title[0:31]
attributes = 0
version = 0
ctime = self.EPOCH_1904 + int(time.time())
mtime = self.EPOCH_1904 + int(time.time())
backup_time = self.EPOCH_1904 + int(time.time())
modnum = 0
appinfo_offset = 0
sort_offset = 0
type = b'BOOK'
creator = b'MOBI'
id_seed = 36
header = struct.pack('>32sHHII',
ensure_binary(short_title), attributes, version,
ctime, mtime)
header += struct.pack('>IIII', backup_time, modnum,
appinfo_offset, sort_offset)
header += struct.pack('>4s4sI',
type, creator, id_seed)
next_record = 0 # not used?
header += struct.pack('>IH', next_record, num_records)
return header, rec_offset
def _GetExthHeader(self):
# They set author, publisher, coveroffset, thumboffset
data = {'author' : self._author,
'publisher' : self._publisher,
}
# Turn string type names into EXTH typeids.
r = []
for key, value in data.items():
typeid = EXTH_HEADER_FIELDS[key]
length_encoding_len = 8
r.append(struct.pack('>LL', typeid, len(value) + length_encoding_len,) + value)
content = b''.join(r)
# logger.debug("len(content):%s"%len(content))
# Pad to word boundary
while len(content) % 4:
content += b'\0'
# logger.debug("len(content):%s"%len(content))
TODO_mysterious = 12
exth = b'EXTH' + struct.pack('>LL', len(content) + TODO_mysterious, len(data)) + content
return exth
def SetImageRecordIndex(self, idx):
self._first_image_index = idx
def MobiHeader(self):
exth_header = self._GetExthHeader();
palmdoc_header = self.PalmDocHeader()
fs = 0xffffffff
# Record 0
header_len = 0xE4 # TODO
mobi_type = 2 # BOOK
text_encoding = encoding['UTF-8']
unique_id = random.randint(1, 1<<32)
creator_version = 4
reserved = b'%c' % 0xff * 40
nonbook_index = fs
# logger.debug("header_len:%s"%header_len)
# logger.debug("len(palmdoc_header):%s"%len(palmdoc_header))
# logger.debug("len(exth_header):%s"%len(exth_header))
full_name_offset = header_len + len(palmdoc_header) + len(exth_header) # put full name after header
language = languages['en-us']
unused = 0
mobi_header = struct.pack('>4sIIIII40sIIIIII',
b'MOBI',
header_len,
mobi_type,
text_encoding,
unique_id,
creator_version,
reserved,
nonbook_index,
full_name_offset,
len(self._title),
language,
fs, fs)
assert len(mobi_header) == 104 - 16
unknown_fields = chr(0) * 32
drm_offset = 0
drm_count = 0
drm_size = 0
drm_flags = 0
exth_flags = 0x50
header_end = chr(0) * 64
mobi_header += struct.pack('>IIIIIII',
creator_version,
self._first_image_index,
fs,
unused,
fs,
unused,
exth_flags)
mobi_header += b'\0' * 112 # TODO: Why this much padding?
# Set some magic offsets to be 0xFFFFFFF.
for pos in (0x94, 0x98, 0xb0, 0xb8, 0xc0, 0xc8, 0xd0, 0xd8, 0xdc):
mobi_header = self._ReplaceWord(mobi_header, pos, fs)
# 16 bytes?
padding = b'\0' * 48 * 4 # why?
total_header = palmdoc_header + mobi_header + exth_header + self._title + padding
return self.AddRecord(total_header, 0)
if __name__ == '__main__':
import sys
m = Converter(title='Testing Mobi', author='Mobi Author', publisher='mobi converter')
m.ConvertFiles(sys.argv[1:], 'test.mobi')
#m.ConvertFile(sys.argv[1], 'test.mobi')
| 32.152174 | 136 | 0.6119 |
ace02d2d48a50c9f78b10bf12f8ca07e6943dd9b | 830 | py | Python | movies/utils.py | scarniglia/django-movies | 165103c1fd441afaabfcf3c3345e4efd981eb4f2 | [
"MIT"
] | null | null | null | movies/utils.py | scarniglia/django-movies | 165103c1fd441afaabfcf3c3345e4efd981eb4f2 | [
"MIT"
] | 4 | 2020-06-05T18:24:44.000Z | 2022-02-26T03:54:30.000Z | movies/utils.py | scarniglia/django-movies | 165103c1fd441afaabfcf3c3345e4efd981eb4f2 | [
"MIT"
] | null | null | null |
class ToRomanError(Exception): pass
class OutOfRangeError(ToRomanError): pass
class NotIntegerError(ToRomanError): pass
ROMAN_NUMERAL_TABLE = (
("M", 1000), ("CM", 900), ("D", 500), ("CD", 400), ("C", 100), ("XC", 90),
("L", 50), ("XL", 40), ("X", 10), ("IX", 9), ("V", 5), ("IV", 4),
("I", 1)
)
def to_roman(number):
""" Convert an integer to Roman
>>> print(convert_to_roman(45))
XLV """
if not (0 < number):
raise OutOfRangeError("number must be non-negative")
if int(number) != number:
raise NotIntegerError("cannot convert decimals")
roman_numerals = []
for numeral, value in ROMAN_NUMERAL_TABLE:
count = number // value
number -= count * value
roman_numerals.append(numeral * count)
return ''.join(roman_numerals) | 28.62069 | 78 | 0.584337 |
ace02dd5706a0bb1623b4f3ce0410ee0162f5363 | 3,622 | py | Python | kubernetes_asyncio/client/models/v1_node_daemon_endpoints.py | weltonrodrigo/kubernetes_asyncio | b793f3e9ea43cbd0f4ff40ace1b0b677682f4042 | [
"Apache-2.0"
] | null | null | null | kubernetes_asyncio/client/models/v1_node_daemon_endpoints.py | weltonrodrigo/kubernetes_asyncio | b793f3e9ea43cbd0f4ff40ace1b0b677682f4042 | [
"Apache-2.0"
] | 13 | 2021-04-12T02:03:48.000Z | 2022-03-28T02:08:46.000Z | kubernetes_asyncio/client/models/v1_node_daemon_endpoints.py | weltonrodrigo/kubernetes_asyncio | b793f3e9ea43cbd0f4ff40ace1b0b677682f4042 | [
"Apache-2.0"
] | null | null | null | # coding: utf-8
"""
Kubernetes
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501
The version of the OpenAPI document: v1.16.14
Generated by: https://openapi-generator.tech
"""
import pprint
import re # noqa: F401
import six
from kubernetes_asyncio.client.configuration import Configuration
class V1NodeDaemonEndpoints(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
openapi_types = {
'kubelet_endpoint': 'V1DaemonEndpoint'
}
attribute_map = {
'kubelet_endpoint': 'kubeletEndpoint'
}
def __init__(self, kubelet_endpoint=None, local_vars_configuration=None): # noqa: E501
"""V1NodeDaemonEndpoints - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration()
self.local_vars_configuration = local_vars_configuration
self._kubelet_endpoint = None
self.discriminator = None
if kubelet_endpoint is not None:
self.kubelet_endpoint = kubelet_endpoint
@property
def kubelet_endpoint(self):
"""Gets the kubelet_endpoint of this V1NodeDaemonEndpoints. # noqa: E501
:return: The kubelet_endpoint of this V1NodeDaemonEndpoints. # noqa: E501
:rtype: V1DaemonEndpoint
"""
return self._kubelet_endpoint
@kubelet_endpoint.setter
def kubelet_endpoint(self, kubelet_endpoint):
"""Sets the kubelet_endpoint of this V1NodeDaemonEndpoints.
:param kubelet_endpoint: The kubelet_endpoint of this V1NodeDaemonEndpoints. # noqa: E501
:type: V1DaemonEndpoint
"""
self._kubelet_endpoint = kubelet_endpoint
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, V1NodeDaemonEndpoints):
return False
return self.to_dict() == other.to_dict()
def __ne__(self, other):
"""Returns true if both objects are not equal"""
if not isinstance(other, V1NodeDaemonEndpoints):
return True
return self.to_dict() != other.to_dict()
| 29.933884 | 124 | 0.610436 |
ace02ddfae5be6033b448163d65fe3387861a4d6 | 2,958 | py | Python | smart_lists/templatetags/smart_list.py | bnkwsk/django-smart-lists | 1bdb99ad5dae62d85accf9f06379e08928552dfc | [
"MIT"
] | null | null | null | smart_lists/templatetags/smart_list.py | bnkwsk/django-smart-lists | 1bdb99ad5dae62d85accf9f06379e08928552dfc | [
"MIT"
] | null | null | null | smart_lists/templatetags/smart_list.py | bnkwsk/django-smart-lists | 1bdb99ad5dae62d85accf9f06379e08928552dfc | [
"MIT"
] | null | null | null | from django import template
from six.moves.urllib_parse import urlencode
from smart_lists.helpers import SmartList
register = template.Library()
@register.inclusion_tag("smart_lists/smart_list.html", takes_context=True)
def smart_list(
context,
object_list=None,
page_obj=None,
is_paginated=None,
paginator=None,
query_params=None,
list_display=None,
list_filter=None,
list_search=None,
search_query_param=None,
ordering_query_param=None,
grid_size=12,
table_class='table-striped',
table_link_class='font-weight-bold',
):
"""
Display the headers and data list together.
TODO: Do pagination inside here??
"""
if object_list is None:
object_list = context['object_list']
if page_obj is None:
page_obj = context.get('page_obj', None)
if is_paginated is None:
is_paginated = context.get('is_paginated')
if paginator is None:
paginator = context.get('paginator')
if query_params is None: # required
query_params = context['smart_list_settings']['query_params']
if list_display is None: # required
list_display = context['smart_list_settings']['list_display']
if list_filter is None: # optional
list_filter = context.get('smart_list_settings', {}).get('list_filter', [])
if list_search is None:
list_search = context.get('smart_list_settings', {}).get('list_search', [])
if search_query_param is None:
search_query_param = context.get('smart_list_settings', {}).get('search_query_param', 'q')
if ordering_query_param is None:
ordering_query_param = context.get('smart_list_settings', {}).get('ordering_query_param', 'o')
smart_list_instance = SmartList(
object_list,
query_params=query_params,
list_display=list_display,
list_filter=list_filter,
list_search=list_search,
search_query_param=search_query_param,
ordering_query_param=ordering_query_param,
view=context['view'],
)
split_grid_small_size = int(round(grid_size * 0.25))
return {
'smart_list': smart_list_instance,
'page_obj': page_obj,
'is_paginated': is_paginated,
'paginator': paginator,
'full_width_grid': grid_size,
'split_grid_large': grid_size - split_grid_small_size,
'split_grid_small': split_grid_small_size,
'table_class': table_class,
'table_link_class': table_link_class,
'query_params': query_params,
'extra': context.get('extra', {}),
}
@register.simple_tag(takes_context=True)
def preserve_query_params(context, **kwargs):
"""
Preserves query parameters.
"""
query_parameters = context.get('query_params', {}).copy() # type: dict
query_parameters.update(kwargs)
return '?' + urlencode(query_parameters)
@register.filter(name='split')
def split(value, arg):
return value.split(arg)
| 31.806452 | 102 | 0.682556 |
ace02e64ef19830d95a7316c9882fbde757cc1ed | 13,113 | py | Python | doc/source/conf.py | cloudmesh/mooc | fcaf46829de1dd5d0f2d9fb4aab937e2b6cec5b4 | [
"Apache-2.0"
] | null | null | null | doc/source/conf.py | cloudmesh/mooc | fcaf46829de1dd5d0f2d9fb4aab937e2b6cec5b4 | [
"Apache-2.0"
] | null | null | null | doc/source/conf.py | cloudmesh/mooc | fcaf46829de1dd5d0f2d9fb4aab937e2b6cec5b4 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
#
# Cloudmesh Plan documentation build configuration file, created by
# sphinx-quickstart on Wed Jun 12 14:38:11 2013.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
import sphinx_bootstrap_theme
# import cloudmesh.util
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# sys.path.insert(0, os.path.abspath('.'))
sys.path.insert(0, os.path.abspath('../..'))
sys.path.insert(0, os.path.abspath('../../..'))
# print "PATH", sys.path
# -- General configuration -----------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.todo',
'sphinx.ext.extlinks',
'sphinx.ext.coverage',
'sphinx.ext.pngmath',
'sphinx.ext.mathjax',
'sphinx.ext.ifconfig',
'sphinx.ext.viewcode',
#'sphinxcontrib.actdiag',
'sphinxcontrib.exceltable',
#'matplotlib.sphinxext.mathmpl',
#'matplotlib.sphinxext.only_directives',
#'matplotlib.sphinxext.plot_directive',
#'matplotlib.sphinxext.ipython_directive',
#'sphinx.ext.autodoc',
#'sphinx.ext.doctest',
#'matplotlib.sphinxext.ipython_console_highlighting',
#'inheritance_diagram',
#'numpydoc'
]
"""
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.doctest',
'sphinx.ext.intersphinx',
'sphinx.ext.todo',
'sphinx.ext.mathjax',
'sphinx.ext.ifconfig',
'sphinx.ext.viewcode',
'sphinxcontrib.webmocks',
'sphinxjp.shibukawa']
"""
#extensions.append('sphinxcontrib.autorun')
#actdiag_fontpath = "/opt/X11/share/fonts/TTF/VeraBd.ttf"
todo_include_todos = True
extlinks = {'jira': ('https://jira.futuregrid.org/browse/%s','issue '),
'portal': ('https://portal.futuregrid.org/%s','https://portal.futuregrid.org/'),
'youtube': ('http://www.youtube.com/watch?v=%s',''),
}
# 'sphinxcontrib.issuetracker']
# issuetracker = 'none',
# issuetracker_project = 'https://jira.futuregrid.org/browse',
# issuetracker_project = 'FG-',
# issuetracker_plaintext_issues = True,
# issuetracker_title_template = '{issue.title} ({issue.id})',
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Cloudmesh'
copyright = u'2013, Cloudmesh, please contact Gregor von Laszewski about this manual.'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.1'
# The full version, including alpha/beta/rc tags.
release = '0.1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
# language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all documents.
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# -- Options for HTML output ---------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
# html_theme = 'default'
html_theme = 'bootstrap'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {}
html_theme_options = {
# Navigation bar title. (Default: ``project`` value)
'navbar_title': "Cloudmesh MOOC Shell",
# Tab name for entire site. (Default: "Site")
'navbar_site_name': "Site",
# Global TOC depth for "site" navbar tab. (Default: 1)
# Switching to -1 shows all levels.
'globaltoc_depth':-1,
# Include hidden TOCs in Site navbar?
#
# Note: If this is "false", you cannot have mixed ``:hidden:`` and
# non-hidden ``toctree`` directives in the same page, or else the build
# will break.
#
# Values: "true" (default) or "false"
'globaltoc_includehidden': "true",
# HTML navbar class (Default: "navbar") to attach to <div> element.
# For black navbar, do "navbar navbar-inverse"
'navbar_class': "navbar navbar-inverse",
# 'navbar_class': "navbar",
# Fix navigation bar to top of page?
# Values: "true" (default) or "false"
'navbar_fixed_top': "true",
# Location of link to source.
# Options are "nav" (default), "footer" or anything else to exclude.
'source_link_position': "nav",
# Bootswatch (http://bootswatch.com/) theme.
#
# Options are nothing with "" (default) or the name of a valid theme
# such as "amelia" or "cosmo".
#
# Note that this is served off CDN, so won't be available offline.
# 'bootswatch_theme': "cosmo",
}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
html_theme_path = sphinx_bootstrap_theme.get_html_theme_path()
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
# html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
html_logo = "images/fg-logo-white-24x36.png"
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
html_show_sphinx = False
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = False
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'FutureGriddoc'
# -- Options for LaTeX output --------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
# 'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'CloudmeshMooc.tex', u'Cloudmesh MOOC Shell Documentation',
u'Gregor von Laszewski', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
# latex_domain_indices = True
# -- Options for manual page output --------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'cloudmesh', u'Cloudmesh MOOC Shell Documentation',
[u'Gregor von Laszewski'], 1)
]
# If true, show URL addresses after external links.
# man_show_urls = False
# -- Options for Texinfo output ------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'Cloudmesh', u'Cloudmesh Documentation',
u'Gregor von Laszewski', 'Cloudmesh', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
# -- Options for Epub output ---------------------------------------------
# Bibliographic Dublin Core info.
epub_title = u'Cloudmesh'
epub_author = u'Gregor von Laszewski'
epub_publisher = u'Gregor von Laszewski'
epub_copyright = u'2013, Gregor von Laszewski'
# The language of the text. It defaults to the language option
# or en if the language is not set.
# epub_language = ''
# The scheme of the identifier. Typical schemes are ISBN or URL.
# epub_scheme = ''
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
# epub_identifier = ''
# A unique identification for the text.
# epub_uid = ''
# A tuple containing the cover image and cover page html template filenames.
# epub_cover = ()
# A sequence of (type, uri, title) tuples for the guide element of content.opf.
# epub_guide = ()
# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
# epub_pre_files = []
# HTML files shat should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
# epub_post_files = []
# A list of files that should not be packed into the epub file.
# epub_exclude_files = []
# The depth of the table of contents in toc.ncx.
# epub_tocdepth = 3
# Allow duplicate toc entries.
# epub_tocdup = True
# Fix unsupported image types using the PIL.
# epub_fix_images = False
# Scale large images.
# epub_max_image_width = 0
# If 'no', URL addresses will not be shown.
# epub_show_urls = 'inline'
# If false, no index is generated.
# epub_use_index = True
# Example configuration for intersphinx: refer to the Python standard library.
intersphinx_mapping = {'http://docs.python.org/': None}
| 31.221429 | 92 | 0.696713 |
ace030b2b9bb7d3dd13c8ca3a15578f768498056 | 7,014 | py | Python | rpglib/combat_system.py | hawson/rpg-text | 64b972d35b5c976c34f38ae7bf770b218f856b7b | [
"MIT"
] | 162 | 2019-08-21T10:17:34.000Z | 2022-02-07T10:43:46.000Z | rpglib/combat_system.py | hawson/rpg-text | 64b972d35b5c976c34f38ae7bf770b218f856b7b | [
"MIT"
] | 18 | 2019-08-21T12:55:13.000Z | 2020-10-01T16:14:45.000Z | rpglib/combat_system.py | hawson/rpg-text | 64b972d35b5c976c34f38ae7bf770b218f856b7b | [
"MIT"
] | 27 | 2019-08-21T12:05:46.000Z | 2022-03-26T12:09:32.000Z | from .utils import sanitized_input, parse_dice_format
import random
import json
from .entity import Entity
from .command_system import CommandException
from .treasure_system import Treasure
class MonsterParty:
def __init__(self, party_name):
super().__init__()
self.monsters = {}
self.name = party_name
if party_name.startswith('party'):
self._init_party()
else:
self._init_single_party()
def __str__(self):
return ", ".join([m.name for m in self.monsters.values()])
def _init_party(self):
with open('data/monster_parties.json') as f:
data = json.load(f).get(self.name, {})
table = data.get('monsters', {})
for monster_name in table.keys():
n_mobs = parse_dice_format(table[monster_name])
for i in range(n_mobs):
self.monsters[monster_name + str(i + 1)] = Monster(monster_name)
self.treasure = data.get("treasure", None)
if not self.treasure:
total_average_value = sum([Treasure(m.treasure).average_value for m in self.monsters.values()])
self.treasure = Treasure.get_type_from_average_value(total_average_value)
def _init_single_party(self):
self.monsters[self.name] = Monster(self.name)
self.treasure = self.monsters[self.name].treasure
def take_combat_turn(self, player):
for monster in self.monsters:
self.monsters[monster].take_combat_turn(player)
def combat_state(self):
return '\n'.join([f"{monster.name} : {monster.health}/{monster.max_health} HP" for monster in self.monsters.values()])
def apply_status_effects(self):
for mob in self.monsters.values():
mob.apply_status_effects()
def get_opponent_from_str(self, opponent):
rv = self.monsters.get(opponent)
if rv:
return rv
else:
raise CommandException("Invalid monster name. Available names are {}".format(", ".join(list(self.monsters.keys()))))
def get_random_opponent(self):
return random.choice(list(self.monsters.values()))
@property
def xp_value(self):
return sum([m.xp_value for m in self.monsters.values()])
@property
def is_dead(self):
rv = True
for mob in self.monsters.values():
if not mob.is_dead:
rv = False
return rv
class Monster(Entity):
def __init__(self, name):
super().__init__()
with open("data/monsters.json") as f:
data = json.load(f).get(name, {})
self.name = name
self.type_name = 'monster'
self.level = data.get("level", 1)
self.lifedice = data.get("lifedice", f"{self.level}d8")
self.max_health = parse_dice_format(self.lifedice)
self.health = self.max_health
self.ac = data.get("ac", 9)
self.attacks = data.get("attacks", {"normal": "1d6"})
self.ac_modifier = data.get("ac_modifier", 0)
self.hit_modifier = data.get("hit_modifier", 0)
self.xp_value = data.get("xp_value", 50)
self.job = data.get("job", "warrior")
self.treasure = data.get("treasure", None)
self.monster_type = data.get("monster_type", None)
@property
def damage(self):
attack = random.choice(list(self.attacks.keys()))
attack_data = self.attacks[attack]
if isinstance(attack_data, str):
return attack, parse_dice_format(attack_data), None
elif isinstance(attack_data, list):
return attack, parse_dice_format(attack_data[0]), attack_data[1:]
def take_combat_turn(self, player):
CombatSystem.attack(self, player)
class CombatSystem:
def __init__(self, game):
self.game = game
self.n_turns = 0
self.fleeing = False
self.current_opponent = None
self.in_combat = False
def start_combat(self, opponent):
self.n_turns = 0
self.in_combat = True
if isinstance(opponent, str):
opponent = MonsterParty(opponent)
elif not isinstance(opponent, (Monster, MonsterParty)):
raise TypeError
self.current_opponent = opponent
while not self.is_combat_finished():
self.n_turns += 1
command = sanitized_input("> ", error_msg="Invalid Command!")
print(self.combat_state())
while not self.game.command_system.parse(command, self.game.command_system.combat_commands):
print("Invalid command. Type 'help' for help.")
command = sanitized_input("> ", error_msg="Invalid Command!")
opponent.apply_status_effects()
self.game.player.apply_status_effects()
opponent.take_combat_turn(self.game.player)
self.finish_combat()
def is_combat_finished(self):
return self.current_opponent.is_dead or self.game.player.is_dead or self.fleeing
def combat_state(self):
opponent = self.current_opponent
player = self.game.player
opponent_status = opponent.combat_state()
player_status = f"{player.name} : {player.health}/{player.max_health} HP {player.mana}/{player.max_mana} MP"
player_moves = " ".join([c.command for c in self.game.command_system.combat_commands])
return "\n".join([opponent_status, player_status, player_moves])
def finish_combat(self):
self.in_combat = False
opponent = self.current_opponent
if self.game.player.is_dead:
self.game.game_over()
else:
self.game.player.end_combat(opponent)
self.game.map.remove_opponent(opponent)
@classmethod
def get_hit(cls, attacker, defender):
diff_lvl = defender.level - attacker.level
def_ac = (20 - defender.ac) + diff_lvl + defender.ac_modifier
rng = parse_dice_format(f"1d20+{attacker.hit_modifier}")
return rng >= def_ac
@classmethod
def attack(cls, attacker, defender):
attack, damage, status_effects = attacker.damage
if CombatSystem.get_hit(attacker, defender):
defender.take_damage(damage)
if status_effects is None:
print(f"{attacker.name} attacked {defender.name} with {attack} and hit for {damage}!")
else:
defender.inflict_status_effects(*status_effects)
print(f"{attacker.name} attacked {defender.name} with {attack} and hit for {damage}"
f"({', '.join(status_effects)})!")
else:
print(f"{attacker.name} attacked {defender.name} with {attack} and did not hit!")
@classmethod
def aoe_attack(cls, attacker, defender):
if isinstance(defender, Entity):
return cls.attack(attacker, defender)
elif isinstance(defender, MonsterParty):
for mob in defender.monsters.values():
cls.attack(attacker, mob)
| 37.709677 | 128 | 0.624608 |
ace0310f4773e1d9905951146bdc3822a1a84515 | 685 | py | Python | Includes/include/python3.py | WikiLibs/Parser | 1a20978a29ab285f80a35c7b55fc484c40d20bbb | [
"BSD-3-Clause"
] | null | null | null | Includes/include/python3.py | WikiLibs/Parser | 1a20978a29ab285f80a35c7b55fc484c40d20bbb | [
"BSD-3-Clause"
] | null | null | null | Includes/include/python3.py | WikiLibs/Parser | 1a20978a29ab285f80a35c7b55fc484c40d20bbb | [
"BSD-3-Clause"
] | null | null | null | import python31 as p3
from python31 import Test as t3
import sys
print('Python', sys.version)
print('\ntiming range()')
print('Python', sys.version)
print('Hello, World!')
print("some text,", end="")
print(' print more text on the same line')
print('Python', sys.version)
print('3 / 2 =', 3 / 2)
print('3 // 2 =', 3 // 2)
print('3 / 2.0 =', 3 / 2.0)
print('3 // 2.0 =', 3 // 2.0)
print('Python', sys.version)
print('strings are now utf-8 \u03BCnico\u0394é!')
print('and Python', sys.version, end="")
print('Python', sys.version)
try:
let_us_cause_a_NameError
except NameError as err:
print(err, '--> our error message')
p3.test_range(10)
t31 = t3()
t31.Do("Heyyyy")
| 18.513514 | 49 | 0.643796 |
ace032d6dafdc4e006c6619effed69d2d8149747 | 4,212 | py | Python | src/rl/q_learning.py | JouniVatanen/NLP-and-Deep-Learning | 2fddcc2c39787713d33d17e80565de4ed073ca60 | [
"MIT"
] | 1 | 2020-05-24T06:55:31.000Z | 2020-05-24T06:55:31.000Z | Machine Learning/rl/q_learning.py | Ashleshk/Machine-Learning-Data-Science-Deep-Learning | 03357ab98155bf73b8f1d2fd53255cc16bea2333 | [
"MIT"
] | null | null | null | Machine Learning/rl/q_learning.py | Ashleshk/Machine-Learning-Data-Science-Deep-Learning | 03357ab98155bf73b8f1d2fd53255cc16bea2333 | [
"MIT"
] | 1 | 2020-03-16T13:11:14.000Z | 2020-03-16T13:11:14.000Z | # https://deeplearningcourses.com/c/artificial-intelligence-reinforcement-learning-in-python
# https://www.udemy.com/artificial-intelligence-reinforcement-learning-in-python
from __future__ import print_function, division
from builtins import range
# Note: you may need to update your version of future
# sudo pip install -U future
import numpy as np
import matplotlib.pyplot as plt
from grid_world import standard_grid, negative_grid
from iterative_policy_evaluation import print_values, print_policy
from monte_carlo_es import max_dict
from td0_prediction import random_action
GAMMA = 0.9
ALPHA = 0.1
ALL_POSSIBLE_ACTIONS = ('U', 'D', 'L', 'R')
if __name__ == '__main__':
# NOTE: if we use the standard grid, there's a good chance we will end up with
# suboptimal policies
# e.g.
# ---------------------------
# R | R | R | |
# ---------------------------
# R* | | U | |
# ---------------------------
# U | R | U | L |
# since going R at (1,0) (shown with a *) incurs no cost, it's OK to keep doing that.
# we'll either end up staying in the same spot, or back to the start (2,0), at which
# point we whould then just go back up, or at (0,0), at which point we can continue
# on right.
# instead, let's penalize each movement so the agent will find a shorter route.
#
# grid = standard_grid()
grid = negative_grid(step_cost=-0.1)
# print rewards
print("rewards:")
print_values(grid.rewards, grid)
# no policy initialization, we will derive our policy from most recent Q
# initialize Q(s,a)
Q = {}
states = grid.all_states()
for s in states:
Q[s] = {}
for a in ALL_POSSIBLE_ACTIONS:
Q[s][a] = 0
# let's also keep track of how many times Q[s] has been updated
update_counts = {}
update_counts_sa = {}
for s in states:
update_counts_sa[s] = {}
for a in ALL_POSSIBLE_ACTIONS:
update_counts_sa[s][a] = 1.0
# repeat until convergence
t = 1.0
deltas = []
for it in range(10000):
if it % 100 == 0:
t += 1e-2
if it % 2000 == 0:
print("it:", it)
# instead of 'generating' an epsiode, we will PLAY
# an episode within this loop
s = (2, 0) # start state
grid.set_state(s)
# the first (s, r) tuple is the state we start in and 0
# (since we don't get a reward) for simply starting the game
# the last (s, r) tuple is the terminal state and the final reward
# the value for the terminal state is by definition 0, so we don't
# care about updating it.
a, _ = max_dict(Q[s])
biggest_change = 0
while not grid.game_over():
a = random_action(a, eps=0.5/t) # epsilon-greedy
# random action also works, but slower since you can bump into walls
# a = np.random.choice(ALL_POSSIBLE_ACTIONS)
r = grid.move(a)
s2 = grid.current_state()
# adaptive learning rate
alpha = ALPHA / update_counts_sa[s][a]
update_counts_sa[s][a] += 0.005
# we will update Q(s,a) AS we experience the episode
old_qsa = Q[s][a]
# the difference between SARSA and Q-Learning is with Q-Learning
# we will use this max[a']{ Q(s',a')} in our update
# even if we do not end up taking this action in the next step
a2, max_q_s2a2 = max_dict(Q[s2])
Q[s][a] = Q[s][a] + alpha*(r + GAMMA*max_q_s2a2 - Q[s][a])
biggest_change = max(biggest_change, np.abs(old_qsa - Q[s][a]))
# we would like to know how often Q(s) has been updated too
update_counts[s] = update_counts.get(s,0) + 1
# next state becomes current state
s = s2
a = a2
deltas.append(biggest_change)
plt.plot(deltas)
plt.show()
# determine the policy from Q*
# find V* from Q*
policy = {}
V = {}
for s in grid.actions.keys():
a, max_q = max_dict(Q[s])
policy[s] = a
V[s] = max_q
# what's the proportion of time we spend updating each part of Q?
print("update counts:")
total = np.sum(list(update_counts.values()))
for k, v in update_counts.items():
update_counts[k] = float(v) / total
print_values(update_counts, grid)
print("values:")
print_values(V, grid)
print("policy:")
print_policy(policy, grid)
| 30.970588 | 92 | 0.633191 |
ace0343b9db78f8a7913afb7f4dcc7b8d86599d3 | 21,708 | py | Python | CPAC/nuisance/nuisance.py | danlurie/C-PAC | 5ddc2d4fa71eb13728d6156f73cb6e7621dda69d | [
"BSD-3-Clause"
] | null | null | null | CPAC/nuisance/nuisance.py | danlurie/C-PAC | 5ddc2d4fa71eb13728d6156f73cb6e7621dda69d | [
"BSD-3-Clause"
] | null | null | null | CPAC/nuisance/nuisance.py | danlurie/C-PAC | 5ddc2d4fa71eb13728d6156f73cb6e7621dda69d | [
"BSD-3-Clause"
] | null | null | null | import nipype.pipeline.engine as pe
import nipype.interfaces.utility as util
import nipype.interfaces.fsl as fsl
import nipype.interfaces.ants as ants
#from nipype import logging
#logger = logging.getLogger('workflow')
def bandpass_voxels(realigned_file, bandpass_freqs, sample_period = None):
"""
Performs ideal bandpass filtering on each voxel time-series.
Parameters
----------
realigned_file : string
Path of a realigned nifti file.
bandpass_freqs : tuple
Tuple containing the bandpass frequencies. (LowCutoff, HighCutoff)
sample_period : float, optional
Length of sampling period in seconds. If not specified,
this value is read from the nifti file provided.
Returns
-------
bandpassed_file : string
Path of filtered output (nifti file).
"""
import os
import nibabel as nb
import numpy as np
def ideal_bandpass(data, sample_period, bandpass_freqs):
#Derived from YAN Chao-Gan 120504 based on REST.
from scipy.fftpack import fft, ifft
# sample_period = T
# LowCutoff = 10.
# HighCutoff = 15.
# data = x
def nextpow2(n):
x = np.log2(n)
return 2**np.ceil(x)
sample_freq = 1./sample_period
sample_length = data.shape[0]
data_p = np.zeros(nextpow2(sample_length))
data_p[:sample_length] = data
LowCutoff, HighCutoff = bandpass_freqs
if(LowCutoff is None): #No lower cutoff (low-pass filter)
low_cutoff_i = 0
elif(LowCutoff > sample_freq/2.): #Cutoff beyond fs/2 (all-stop filter)
low_cutoff_i = int(data_p.shape[0]/2)
else:
low_cutoff_i = np.ceil(LowCutoff*data_p.shape[0]*sample_period).astype('int')
if(HighCutoff > sample_freq/2. or HighCutoff is None): #Cutoff beyond fs/2 or unspecified (become a highpass filter)
high_cutoff_i = int(data_p.shape[0]/2)
else:
high_cutoff_i = np.fix(HighCutoff*data_p.shape[0]*sample_period).astype('int')
freq_mask = np.zeros_like(data_p, dtype='bool')
freq_mask[low_cutoff_i:high_cutoff_i+1] = True
freq_mask[data_p.shape[0]-high_cutoff_i:data_p.shape[0]+1-low_cutoff_i] = True
f_data = fft(data_p)
f_data[freq_mask != True] = 0.
data_bp = np.real_if_close(ifft(f_data)[:sample_length])
return data_bp
nii = nb.load(realigned_file)
data = nii.get_data().astype('float64')
mask = (data != 0).sum(-1) != 0
Y = data[mask].T
Yc = Y - np.tile(Y.mean(0), (Y.shape[0], 1))
if not sample_period:
hdr = nii.get_header()
sample_period = float(hdr.get_zooms()[3])
# Sketchy check to convert TRs in millisecond units
if sample_period > 20.0:
sample_period /= 1000.0
print 'Frequency filtering using sample period: ', sample_period, 'sec'
Y_bp = np.zeros_like(Y)
for j in range(Y.shape[1]):
Y_bp[:,j] = ideal_bandpass(Yc[:,j], sample_period, bandpass_freqs)
data[mask] = Y_bp.T
img = nb.Nifti1Image(data, header=nii.get_header(), affine=nii.get_affine())
bandpassed_file = os.path.join(os.getcwd(), 'bandpassed_demeaned_filtered.nii.gz')
img.to_filename(bandpassed_file)
return bandpassed_file
def calc_residuals(subject,
selector,
wm_sig_file = None,
csf_sig_file = None,
gm_sig_file = None,
motion_file = None,
compcor_ncomponents = 0):
"""
Calculates residuals of nuisance regressors for every voxel for a subject.
Parameters
----------
subject : string
Path of a subject's realigned nifti file.
selector : dictionary
Dictionary of selected regressors. Keys are represented as a string of the regressor name and keys
are True/False. See notes for an example.
wm_mask_file : string, optional
Path to subject's white matter mask (in the same space as the subject's functional file)
csf_mask_file : string, optional
Path to subject's cerebral spinal fluid mask (in the same space as the subject's functional file)
gm_mask_file : string, optional
Path to subject's grey matter mask (in the same space as the subject's functional file)
compcor_ncomponents : integer, optional
The first `n` principal of CompCor components to use as regressors. Default is 0.
Returns
-------
residual_file : string
Path of residual file in nifti format
regressors_file : string
Path of csv file of regressors used. Filename corresponds to the name of each
regressor in each column.
Notes
-----
Example of selector parameter:
>>> selector = {'compcor' : True,
>>> 'wm' : True,
>>> 'csf' : True,
>>> 'gm' : True,
>>> 'global' : True,
>>> 'pc1' : True,
>>> 'motion' : True,
>>> 'linear' : True,
>>> 'quadratic' : True}
"""
import numpy as np
import nibabel as nb
import os
import scipy
from CPAC.nuisance import calc_compcor_components
nii = nb.load(subject)
data = nii.get_data().astype(np.float64)
global_mask = (data != 0).sum(-1) != 0
#Check and define regressors which are provided from files
if wm_sig_file is not None:
wm_sigs = np.load(wm_sig_file)
if wm_sigs.shape[1] != data.shape[3]:
raise ValueError('White matter signals length %d do not match data timepoints %d' % (wm_sigs.shape[1], data.shape[3]))
if csf_sig_file is not None:
csf_sigs = np.load(csf_sig_file)
if csf_sigs.shape[1] != data.shape[3]:
raise ValueError('CSF signals length %d do not match data timepoints %d' % (csf_sigs.shape[1], data.shape[3]))
if gm_sig_file is not None:
gm_sigs = np.load(gm_sig_file)
if gm_sigs.shape[1] != data.shape[3]:
raise ValueError('Grey matter signals length %d do not match data timepoints %d' % (gm_sigs.shape[1], data.shape[3]))
if motion_file is not None:
motion = np.genfromtxt(motion_file)
if motion.shape[0] != data.shape[3]:
raise ValueError('Motion parameters %d do not match data timepoints %d' % (motion.shape[0], data.shape[3]) )
#Calculate regressors
regressor_map = {'constant' : np.ones((data.shape[3],1))}
if(selector['compcor']):
print 'compcor_ncomponents ', compcor_ncomponents
regressor_map['compcor'] = calc_compcor_components(data, compcor_ncomponents, wm_sigs, csf_sigs)
if(selector['wm']):
regressor_map['wm'] = wm_sigs.mean(0)
if(selector['csf']):
regressor_map['csf'] = csf_sigs.mean(0)
if(selector['gm']):
regressor_map['gm'] = gm_sigs.mean(0)
if(selector['global']):
regressor_map['global'] = data[global_mask].mean(0)
if(selector['pc1']):
bdata = data[global_mask].T
bdatac = bdata - np.tile(bdata.mean(0), (bdata.shape[0], 1))
U, S, Vh = np.linalg.svd(bdatac, full_matrices=False)
regressor_map['pc1'] = U[:,0]
if(selector['motion']):
regressor_map['motion'] = motion
if(selector['linear']):
regressor_map['linear'] = np.arange(0, data.shape[3])
if(selector['quadratic']):
regressor_map['quadratic'] = np.arange(0, data.shape[3])**2
print 'Regressors include: ', regressor_map.keys()
X = np.zeros((data.shape[3], 1))
csv_filename = ''
for rname, rval in regressor_map.items():
X = np.hstack((X, rval.reshape(rval.shape[0],-1)))
csv_filename += '_' + rname
X = X[:,1:]
csv_filename = csv_filename[1:]
csv_filename += '.csv'
csv_filename = os.path.join(os.getcwd(), csv_filename)
np.savetxt(csv_filename, X, delimiter='\t')
print 'Regressors dim: ', X.shape, ' starting regression'
Y = data[global_mask].T
B = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(Y)
Y_res = Y - X.dot(B)
data[global_mask] = Y_res.T
print 'Writing residual and regressors'
img = nb.Nifti1Image(data, header=nii.get_header(), affine=nii.get_affine())
residual_file = os.path.join(os.getcwd(), 'residual.nii.gz')
img.to_filename(residual_file)
#Easier to read for debugging purposes
regressors_file = os.path.join(os.getcwd(), 'nuisance_regressors.mat')
if scipy.__version__ == '0.7.0':
scipy.io.savemat(regressors_file, regressor_map) ### for scipy v0.7.0
else:
scipy.io.savemat(regressors_file, regressor_map, oned_as='column') ### for scipy v0.12: OK
return residual_file, csv_filename
def extract_tissue_data(data_file,
ventricles_mask_file,
wm_seg_file, csf_seg_file, gm_seg_file,
wm_threshold=0.0, csf_threshold=0.0, gm_threshold=0.0):
import numpy as np
import nibabel as nb
import os
from CPAC.nuisance import erode_mask
from CPAC.utils import safe_shape
print 'Tissues extraction thresholds wm %d, csf %d, gm %d' % (wm_threshold,
csf_threshold,
gm_threshold)
try:
data = nb.load(data_file).get_data().astype('float64')
except:
raise MemoryError('Unable to load %s' % data_file)
try:
lat_ventricles_mask = nb.load(ventricles_mask_file).get_data().astype('float64')
except:
raise MemoryError('Unable to load %s' % lat_ventricles_mask)
if not safe_shape(data, lat_ventricles_mask):
raise ValueError('Spatial dimensions for data and the lateral ventricles mask do not match')
try:
wm_seg = nb.load(wm_seg_file).get_data().astype('float64')
except:
raise MemoryError('Unable to load %s' % wm_seg)
if not safe_shape(data, wm_seg):
raise ValueError('Spatial dimensions for data, white matter segment do not match')
wm_mask = erode_mask(wm_seg > wm_threshold)
wm_sigs = data[wm_mask]
file_wm = os.path.join(os.getcwd(), 'wm_signals.npy')
np.save(file_wm, wm_sigs)
del wm_sigs
try:
csf_seg = nb.load(csf_seg_file).get_data().astype('float64')
except:
raise MemoryError('Unable to load %s' % csf_seg)
if not safe_shape(data, csf_seg):
raise ValueError('Spatial dimensions for data, cerebral spinal fluid segment do not match')
# Only take the CSF at the lateral ventricles as labeled in the Harvard
# Oxford parcellation regions 4 and 43
csf_mask = (csf_seg > csf_threshold)*(lat_ventricles_mask==1)
csf_sigs = data[csf_mask]
file_csf = os.path.join(os.getcwd(), 'csf_signals.npy')
np.save(file_csf, csf_sigs)
del csf_sigs
try:
gm_seg = nb.load(gm_seg_file).get_data().astype('float64')
except:
raise MemoryError('Unable to load %s' % gm_seg)
if not safe_shape(data, gm_seg):
raise ValueError('Spatial dimensions for data, gray matter segment do not match')
gm_mask = erode_mask(gm_seg > gm_threshold)
gm_sigs = data[gm_mask]
file_gm = os.path.join(os.getcwd(), 'gm_signals.npy')
np.save(file_gm, gm_sigs)
del gm_sigs
nii = nb.load(wm_seg_file)
wm_mask_file = os.path.join(os.getcwd(), 'wm_mask.nii.gz')
csf_mask_file = os.path.join(os.getcwd(), 'csf_mask.nii.gz')
gm_mask_file = os.path.join(os.getcwd(), 'gm_mask.nii.gz')
nb.Nifti1Image(wm_mask, header=nii.get_header(), affine=nii.get_affine()).to_filename(wm_mask_file)
nb.Nifti1Image(csf_mask, header=nii.get_header(), affine=nii.get_affine()).to_filename(csf_mask_file)
nb.Nifti1Image(gm_mask, header=nii.get_header(), affine=nii.get_affine()).to_filename(gm_mask_file)
return file_wm, file_csf, file_gm
def create_nuisance(use_ants, name='nuisance'):
"""
Workflow for the removal of various signals considered to be noise in resting state
fMRI data. The residual signals for linear regression denoising is performed in a single
model. Therefore the residual time-series will be orthogonal to all signals.
Parameters
----------
name : string, optional
Name of the workflow.
Returns
-------
nuisance : nipype.pipeline.engine.Workflow
Nuisance workflow.
Notes
-----
Workflow Inputs::
inputspec.subject : string (nifti file)
Path of the subject's realigned nifti file.
inputspec.wm_mask : string (nifti file)
Corresponding white matter mask.
inputspec.csf_mask : string (nifti file)
Corresponding cerebral spinal fluid mask.
inputspec.gm_mask : string (nifti file)
Corresponding grey matter mask.
inputspec.mni_to_anat_linear_xfm : string (nifti file)
Corresponding MNI to anatomical linear transformation
inputspec.func_to_anat_linear_xfm : string (nifti file)
Corresponding EPI to anatomical linear transformation
inputspec.harvard_oxford_mask : string (nifti file)
Harvard Oxford parcellation for ventrical locations
inputspec.motion_components : string (text file)
Corresponding rigid-body motion parameters. Matrix in the file should be of shape
(`T`, `R`), `T` timepoints and `R` motion parameters.
inputspec.selector : dictionary
inputspec.compcor_ncomponents : integer
Workflow Outputs::
outputspec.subject : string (nifti file)
Path of residual file in nifti format
outputspec.regressors : string (mat file)
Path of csv file of regressors used. Filename corresponds to the name of each
regressor in each column.
Nuisance Procedure:
1. Compute nuisance regressors based on input selections.
2. Calculate residuals with respect to these nuisance regressors in a
single model for every voxel.
Workflow Graph:
.. image:: ../images/nuisance.dot.png
:width: 500
Detailed Workflow Graph:
.. image:: ../images/nuisance_detailed.dot.png
:width: 500
"""
nuisance = pe.Workflow(name=name)
inputspec = pe.Node(util.IdentityInterface(fields=['subject',
'wm_mask',
'csf_mask',
'gm_mask',
'mni_to_anat_linear_xfm',
'anat_to_mni_initial_xfm',
'anat_to_mni_rigid_xfm',
'anat_to_mni_affine_xfm',
'func_to_anat_linear_xfm',
'lat_ventricles_mask',
'motion_components',
'selector',
'compcor_ncomponents',
'template_brain']),
name='inputspec')
outputspec = pe.Node(util.IdentityInterface(fields=['subject',
'regressors']),
name='outputspec')
# Resampling the masks from 1mm to 2mm, but remaining in subject space
wm_anat_to_2mm = pe.Node(interface=fsl.FLIRT(), name='wm_anat_to_2mm_flirt_applyxfm')
wm_anat_to_2mm.inputs.args = '-applyisoxfm 2'
wm_anat_to_2mm.inputs.interp = 'nearestneighbour'
nuisance.connect(inputspec, 'wm_mask', wm_anat_to_2mm, 'in_file')
nuisance.connect(inputspec, 'wm_mask', wm_anat_to_2mm, 'reference')
# Resampling the masks from 1mm to 2mm, but remaining in subject space
csf_anat_to_2mm = pe.Node(interface=fsl.FLIRT(), name='csf_anat_to_2mm_flirt_applyxfm')
csf_anat_to_2mm.inputs.args = '-applyisoxfm 2'
csf_anat_to_2mm.inputs.interp = 'nearestneighbour'
nuisance.connect(inputspec, 'csf_mask', csf_anat_to_2mm, 'in_file')
nuisance.connect(inputspec, 'csf_mask', csf_anat_to_2mm, 'reference')
# Resampling the masks from 1mm to 2mm, but remaining in subject space
gm_anat_to_2mm = pe.Node(interface=fsl.FLIRT(), name='gm_anat_to_2mm_flirt_applyxfm')
gm_anat_to_2mm.inputs.args = '-applyisoxfm 2'
gm_anat_to_2mm.inputs.interp = 'nearestneighbour'
nuisance.connect(inputspec, 'gm_mask', gm_anat_to_2mm, 'in_file')
nuisance.connect(inputspec, 'gm_mask', gm_anat_to_2mm, 'reference')
func_to_2mm = pe.Node(interface=fsl.FLIRT(), name='func_to_2mm_flirt_applyxfm')
func_to_2mm.inputs.args = '-applyisoxfm 2'
nuisance.connect(inputspec, 'subject', func_to_2mm, 'in_file')
nuisance.connect(inputspec, 'csf_mask', func_to_2mm, 'reference')
nuisance.connect(inputspec, 'func_to_anat_linear_xfm', func_to_2mm, 'in_matrix_file')
if use_ants == True:
collect_linear_transforms = pe.Node(util.Merge(3), name='ho_mni_to_2mm_ants_collect_linear_transforms')
ho_mni_to_2mm = pe.Node(interface=ants.ApplyTransforms(), name='ho_mni_to_2mm_ants_applyxfm')
ho_mni_to_2mm.inputs.invert_transform_flags = [True, True, True]
ho_mni_to_2mm.inputs.interpolation = 'NearestNeighbor'
ho_mni_to_2mm.inputs.dimension = 3
nuisance.connect(inputspec, 'anat_to_mni_initial_xfm', collect_linear_transforms, 'in1')
nuisance.connect(inputspec, 'anat_to_mni_rigid_xfm', collect_linear_transforms, 'in2')
nuisance.connect(inputspec, 'anat_to_mni_affine_xfm', collect_linear_transforms, 'in3')
nuisance.connect(collect_linear_transforms, 'out', ho_mni_to_2mm, 'transforms')
nuisance.connect(inputspec, 'lat_ventricles_mask', ho_mni_to_2mm, 'input_image')
nuisance.connect(csf_anat_to_2mm, 'out_file', ho_mni_to_2mm, 'reference_image')
#resample_to_2mm = pe.Node(interface=afni.Resample(), name='resample_to_2mm_ants_output'
else:
ho_mni_to_2mm = pe.Node(interface=fsl.FLIRT(), name='ho_mni_to_2mm_flirt_applyxfm')
ho_mni_to_2mm.inputs.args = '-applyisoxfm 2'
ho_mni_to_2mm.inputs.interp = 'nearestneighbour'
nuisance.connect(inputspec, 'mni_to_anat_linear_xfm', ho_mni_to_2mm, 'in_matrix_file')
nuisance.connect(inputspec, 'lat_ventricles_mask', ho_mni_to_2mm, 'in_file')
nuisance.connect(inputspec, 'csf_mask', ho_mni_to_2mm, 'reference')
tissue_masks = pe.Node(util.Function(input_names=['data_file',
'ventricles_mask_file',
'wm_seg_file', 'csf_seg_file', 'gm_seg_file',
'wm_threshold', 'csf_threshold', 'gm_threshold'],
output_names=['file_wm', 'file_csf', 'file_gm'],
function=extract_tissue_data),
name='tissue_masks')
nuisance.connect(func_to_2mm, 'out_file', tissue_masks, 'data_file')
nuisance.connect(wm_anat_to_2mm, 'out_file', tissue_masks, 'wm_seg_file')
nuisance.connect(csf_anat_to_2mm, 'out_file', tissue_masks, 'csf_seg_file')
nuisance.connect(gm_anat_to_2mm, 'out_file', tissue_masks, 'gm_seg_file')
if use_ants == True:
nuisance.connect(ho_mni_to_2mm, 'output_image', tissue_masks, 'ventricles_mask_file')
else:
nuisance.connect(ho_mni_to_2mm, 'out_file', tissue_masks, 'ventricles_mask_file')
calc_r = pe.Node(util.Function(input_names=['subject',
'selector',
'wm_sig_file',
'csf_sig_file',
'gm_sig_file',
'motion_file',
'compcor_ncomponents'],
output_names=['residual_file',
'regressors_file'],
function=calc_residuals),
name='residuals')
nuisance.connect(inputspec, 'subject',
calc_r, 'subject')
nuisance.connect(tissue_masks, 'file_wm',
calc_r, 'wm_sig_file')
nuisance.connect(tissue_masks, 'file_csf',
calc_r, 'csf_sig_file')
nuisance.connect(tissue_masks, 'file_gm',
calc_r, 'gm_sig_file')
nuisance.connect(inputspec, 'motion_components',
calc_r, 'motion_file')
nuisance.connect(inputspec, 'selector',
calc_r, 'selector')
nuisance.connect(inputspec, 'compcor_ncomponents',
calc_r, 'compcor_ncomponents')
nuisance.connect(calc_r, 'residual_file',
outputspec, 'subject')
nuisance.connect(calc_r, 'regressors_file',
outputspec, 'regressors')
return nuisance
| 38.557726 | 130 | 0.605353 |
ace034fb4c0d90bdbffe6921df2bbe3c1b6bb7ff | 202 | py | Python | ctlr/libertytimes/__init__.py | g0v/news-diff | 62735843716159a242aef697571f364d61be788f | [
"MIT"
] | 10 | 2015-09-27T14:28:49.000Z | 2022-03-31T05:42:25.000Z | ctlr/libertytimes/__init__.py | g0v/news-diff | 62735843716159a242aef697571f364d61be788f | [
"MIT"
] | null | null | null | ctlr/libertytimes/__init__.py | g0v/news-diff | 62735843716159a242aef697571f364d61be788f | [
"MIT"
] | 4 | 2015-02-19T08:22:31.000Z | 2019-11-13T04:18:41.000Z | # -*- coding: utf-8 -*-
#
# http://www.libertytimes.com.tw/Service/rss.htm
#
host = {
"name": "自由時報",
"url": "http://www.libertytimes.com.tw/",
}
import ctlr_20130719
Ctlrs = [ctlr_20130719.Ctlr]
| 15.538462 | 48 | 0.628713 |
ace038d369e463db9f3df1f604d80766c63a78ea | 6,515 | py | Python | src/lib/models/networks/DCNv2/dcn_v2_func.py | evitself/CenterNet | db3714397c776f3f84c6ab9b61a47160f78462f5 | [
"MIT"
] | null | null | null | src/lib/models/networks/DCNv2/dcn_v2_func.py | evitself/CenterNet | db3714397c776f3f84c6ab9b61a47160f78462f5 | [
"MIT"
] | null | null | null | src/lib/models/networks/DCNv2/dcn_v2_func.py | evitself/CenterNet | db3714397c776f3f84c6ab9b61a47160f78462f5 | [
"MIT"
] | null | null | null | #!/usr/bin/env python
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
import torch
from torch.autograd import Function
import dcn_v2 as _backend
# from _ext import dcn_v2_double as _backend
class DCNv2Function(Function):
def __init__(self, stride, padding, dilation=1, deformable_groups=1):
super(DCNv2Function, self).__init__()
self.stride = stride
self.padding = padding
self.dilation = dilation
self.deformable_groups = deformable_groups
def forward(self, input, offset, mask, weight, bias):
if not input.is_cuda:
raise NotImplementedError
if weight.requires_grad or mask.requires_grad or offset.requires_grad or input.requires_grad:
self.save_for_backward(input, offset, mask, weight, bias)
output = input.new(*self._infer_shape(input, weight))
self._bufs = [input.new(), input.new()]
_backend.dcn_v2_cuda_forward(input, weight,
bias, self._bufs[0],
offset, mask,
output, self._bufs[1],
weight.shape[2], weight.shape[3],
self.stride, self.stride,
self.padding, self.padding,
self.dilation, self.dilation,
self.deformable_groups)
return output
def backward(self, grad_output):
if not grad_output.is_cuda:
raise NotImplementedError
input, offset, mask, weight, bias = self.saved_tensors
grad_input = input.new(*input.size()).zero_()
grad_offset = offset.new(*offset.size()).zero_()
grad_mask = mask.new(*mask.size()).zero_()
grad_weight = weight.new(*weight.size()).zero_()
grad_bias = bias.new(*bias.size()).zero_()
_backend.dcn_v2_cuda_backward(input, weight,
bias, self._bufs[0],
offset, mask,
self._bufs[1],
grad_input, grad_weight,
grad_bias, grad_offset,
grad_mask, grad_output,
weight.shape[2], weight.shape[3],
self.stride, self.stride,
self.padding, self.padding,
self.dilation, self.dilation,
self.deformable_groups)
return grad_input, grad_offset, grad_mask, grad_weight, grad_bias
def _infer_shape(self, input, weight):
n = input.size(0)
channels_out = weight.size(0)
height, width = input.shape[2:4]
kernel_h, kernel_w = weight.shape[2:4]
height_out = (height + 2 * self.padding -
(self.dilation * (kernel_h - 1) + 1)) // self.stride + 1
width_out = (width + 2 * self.padding - (self.dilation *
(kernel_w - 1) + 1)) // self.stride + 1
return (n, channels_out, height_out, width_out)
class DCNv2PoolingFunction(Function):
def __init__(self,
spatial_scale,
pooled_size,
output_dim,
no_trans,
group_size=1,
part_size=None,
sample_per_part=4,
trans_std=.0):
super(DCNv2PoolingFunction, self).__init__()
self.spatial_scale = spatial_scale
self.pooled_size = pooled_size
self.output_dim = output_dim
self.no_trans = no_trans
self.group_size = group_size
self.part_size = pooled_size if part_size is None else part_size
self.sample_per_part = sample_per_part
self.trans_std = trans_std
assert self.trans_std >= 0.0 and self.trans_std <= 1.0
def forward(self, data, rois, offset):
if not data.is_cuda:
raise NotImplementedError
output = data.new(*self._infer_shape(data, rois))
output_count = data.new(*self._infer_shape(data, rois))
_backend.dcn_v2_psroi_pooling_cuda_forward(data, rois, offset,
output, output_count,
self.no_trans, self.spatial_scale,
self.output_dim, self.group_size,
self.pooled_size, self.part_size,
self.sample_per_part, self.trans_std)
if data.requires_grad or rois.requires_grad or offset.requires_grad:
self.save_for_backward(data, rois, offset, output_count)
return output
def backward(self, grad_output):
if not grad_output.is_cuda:
raise NotImplementedError
data, rois, offset, output_count = self.saved_tensors
grad_input = data.new(*data.size()).zero_()
grad_offset = offset.new(*offset.size()).zero_()
_backend.dcn_v2_psroi_pooling_cuda_backward(grad_output,
data,
rois,
offset,
output_count,
grad_input,
grad_offset,
self.no_trans,
self.spatial_scale,
self.output_dim,
self.group_size,
self.pooled_size,
self.part_size,
self.sample_per_part,
self.trans_std)
return grad_input, None, grad_offset
def _infer_shape(self, data, rois):
# _, c, h, w = data.shape[:4]
c = data.shape[1]
n = rois.shape[0]
return (n, self.output_dim, self.pooled_size, self.pooled_size)
| 44.319728 | 101 | 0.489486 |
ace03928f06b98774301689217ef1663e25eb552 | 55 | py | Python | bali/resource.py | Ed-XCF/bali | ac2facd7390309fa9bbfe32c3ca33bd7556096d8 | [
"MIT"
] | 18 | 2020-11-02T11:28:25.000Z | 2022-03-30T02:04:07.000Z | bali/resource.py | Ed-XCF/bali | ac2facd7390309fa9bbfe32c3ca33bd7556096d8 | [
"MIT"
] | 19 | 2020-10-13T05:39:01.000Z | 2022-02-19T16:26:56.000Z | bali/resource.py | Ed-XCF/bali | ac2facd7390309fa9bbfe32c3ca33bd7556096d8 | [
"MIT"
] | 9 | 2020-11-03T09:09:17.000Z | 2021-09-07T03:01:46.000Z | # Compatible with 1.x version
from .resources import *
| 18.333333 | 29 | 0.763636 |
ace0394c4c6c2a38b8d9d3808bffd7fdc1f62336 | 6,864 | py | Python | venv/lib/python3.6/site-packages/ansible_collections/cisco/mso/plugins/modules/mso_schema_site_bd.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | 1 | 2020-01-22T13:11:23.000Z | 2020-01-22T13:11:23.000Z | venv/lib/python3.6/site-packages/ansible_collections/cisco/mso/plugins/modules/mso_schema_site_bd.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | 12 | 2020-02-21T07:24:52.000Z | 2020-04-14T09:54:32.000Z | venv/lib/python3.6/site-packages/ansible_collections/cisco/mso/plugins/modules/mso_schema_site_bd.py | usegalaxy-no/usegalaxy | 75dad095769fe918eb39677f2c887e681a747f3a | [
"MIT"
] | null | null | null | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright: (c) 2019, Dag Wieers (@dagwieers) <dag@wieers.com>
# GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = r'''
---
module: mso_schema_site_bd
short_description: Manage site-local Bridge Domains (BDs) in schema template
description:
- Manage site-local BDs in schema template on Cisco ACI Multi-Site.
author:
- Dag Wieers (@dagwieers)
options:
schema:
description:
- The name of the schema.
type: str
required: yes
site:
description:
- The name of the site.
type: str
required: yes
template:
description:
- The name of the template.
type: str
required: yes
bd:
description:
- The name of the BD to manage.
type: str
aliases: [ name ]
host_route:
description:
- Whether host-based routing is enabled.
type: bool
svi_mac:
description:
- SVI MAC Address
type: str
state:
description:
- Use C(present) or C(absent) for adding or removing.
- Use C(query) for listing an object or multiple objects.
type: str
choices: [ absent, present, query ]
default: present
seealso:
- module: cisco.mso.mso_schema_site
- module: cisco.mso.mso_schema_site_bd_l3out
- module: cisco.mso.mso_schema_site_bd_subnet
- module: cisco.mso.mso_schema_template_bd
extends_documentation_fragment: cisco.mso.modules
'''
EXAMPLES = r'''
- name: Add a new site BD
cisco.mso.mso_schema_site_bd:
host: mso_host
username: admin
password: SomeSecretPassword
schema: Schema1
site: Site1
template: Template1
bd: BD1
state: present
delegate_to: localhost
- name: Remove a site BD
cisco.mso.mso_schema_site_bd:
host: mso_host
username: admin
password: SomeSecretPassword
schema: Schema1
site: Site1
template: Template1
bd: BD1
state: absent
delegate_to: localhost
- name: Query a specific site BD
cisco.mso.mso_schema_site_bd:
host: mso_host
username: admin
password: SomeSecretPassword
schema: Schema1
site: Site1
template: Template1
bd: BD1
state: query
delegate_to: localhost
register: query_result
- name: Query all site BDs
cisco.mso.mso_schema_site_bd:
host: mso_host
username: admin
password: SomeSecretPassword
schema: Schema1
site: Site1
template: Template1
state: query
delegate_to: localhost
register: query_result
'''
RETURN = r'''
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.cisco.mso.plugins.module_utils.mso import MSOModule, mso_argument_spec
def main():
argument_spec = mso_argument_spec()
argument_spec.update(
schema=dict(type='str', required=True),
site=dict(type='str', required=True),
template=dict(type='str', required=True),
bd=dict(type='str', aliases=['name']), # This parameter is not required for querying all objects
host_route=dict(type='bool'),
svi_mac=dict(type='str'),
state=dict(type='str', default='present', choices=['absent', 'present', 'query']),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
['state', 'absent', ['bd']],
['state', 'present', ['bd']],
],
)
schema = module.params.get('schema')
site = module.params.get('site')
template = module.params.get('template').replace(' ', '')
bd = module.params.get('bd')
host_route = module.params.get('host_route')
svi_mac = module.params.get('svi_mac')
state = module.params.get('state')
mso = MSOModule(module)
# Get schema objects
schema_id, schema_path, schema_obj = mso.query_schema(schema)
# Get template
templates = [t.get('name') for t in schema_obj.get('templates')]
if template not in templates:
mso.fail_json(msg="Provided template '{0}' does not exist. Existing templates: {1}".format(template, ', '.join(templates)))
# Get site
site_id = mso.lookup_site(site)
# Get site_idx
if 'sites' not in schema_obj:
mso.fail_json(msg="No site associated with template '{0}'. Associate the site with the template using mso_schema_site.".format(template))
sites = [(s.get('siteId'), s.get('templateName')) for s in schema_obj.get('sites')]
if (site_id, template) not in sites:
mso.fail_json(msg="Provided site-template association '{0}-{1}' does not exist.".format(site, template))
# Schema-access uses indexes
site_idx = sites.index((site_id, template))
# Path-based access uses site_id-template
site_template = '{0}-{1}'.format(site_id, template)
# Get BD
bd_ref = mso.bd_ref(schema_id=schema_id, template=template, bd=bd)
bds = [v.get('bdRef') for v in schema_obj.get('sites')[site_idx]['bds']]
if bd is not None and bd_ref in bds:
bd_idx = bds.index(bd_ref)
bd_path = '/sites/{0}/bds/{1}'.format(site_template, bd)
mso.existing = schema_obj.get('sites')[site_idx]['bds'][bd_idx]
mso.existing['bdRef'] = mso.dict_from_ref(mso.existing.get('bdRef'))
if state == 'query':
if bd is None:
mso.existing = schema_obj.get('sites')[site_idx]['bds']
for bd in mso.existing:
bd['bdRef'] = mso.dict_from_ref(bd.get('bdRef'))
elif not mso.existing:
mso.fail_json(msg="BD '{bd}' not found".format(bd=bd))
mso.exit_json()
bds_path = '/sites/{0}/bds'.format(site_template)
ops = []
mso.previous = mso.existing
if state == 'absent':
if mso.existing:
mso.sent = mso.existing = {}
ops.append(dict(op='remove', path=bd_path))
elif state == 'present':
if not mso.existing:
if host_route is None:
host_route = False
payload = dict(
bdRef=dict(
schemaId=schema_id,
templateName=template,
bdName=bd,
),
hostBasedRouting=host_route,
)
if svi_mac is not None:
payload.update(mac=svi_mac)
mso.sanitize(payload, collate=True)
if mso.existing:
ops.append(dict(op='replace', path=bd_path, value=mso.sent))
else:
ops.append(dict(op='add', path=bds_path + '/-', value=mso.sent))
mso.existing = mso.proposed
if not module.check_mode and mso.existing != mso.previous:
mso.request(schema_path, method='PATCH', data=ops)
mso.exit_json()
if __name__ == "__main__":
main()
| 28.840336 | 145 | 0.639569 |
ace0399a1f3367775c65ebcf4175e85347a5003e | 10,763 | py | Python | roll_dep.py | augushong/depot_tools | a39e2d318b04122c783a6b6e30ae90e9a04e7929 | [
"BSD-3-Clause"
] | 4 | 2022-03-21T15:21:13.000Z | 2022-03-23T16:31:20.000Z | roll_dep.py | augushong/depot_tools | a39e2d318b04122c783a6b6e30ae90e9a04e7929 | [
"BSD-3-Clause"
] | null | null | null | roll_dep.py | augushong/depot_tools | a39e2d318b04122c783a6b6e30ae90e9a04e7929 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python
# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Rolls DEPS controlled dependency.
Works only with git checkout and git dependencies. Currently this script will
always roll to the tip of to origin/main.
"""
from __future__ import print_function
import argparse
import os
import re
import subprocess2
import sys
NEED_SHELL = sys.platform.startswith('win')
GCLIENT_PATH = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'gclient.py')
# Commit subject that will be considered a roll. In the format generated by the
# git log used, so it's "<year>-<month>-<day> <author> <subject>"
_ROLL_SUBJECT = re.compile(
# Date
r'^\d\d\d\d-\d\d-\d\d '
# Author
r'[^ ]+ '
# Subject
r'('
# Generated by
# https://skia.googlesource.com/buildbot/+/HEAdA/autoroll/go/repo_manager/deps_repo_manager.go
r'Roll [^ ]+ [a-f0-9]+\.\.[a-f0-9]+ \(\d+ commits\)'
r'|'
# Generated by
# https://chromium.googlesource.com/infra/infra/+/HEAD/recipes/recipe_modules/recipe_autoroller/api.py
r'Roll recipe dependencies \(trivial\)\.'
r')$')
class Error(Exception):
pass
class AlreadyRolledError(Error):
pass
def check_output(*args, **kwargs):
"""subprocess2.check_output() passing shell=True on Windows for git."""
kwargs.setdefault('shell', NEED_SHELL)
return subprocess2.check_output(*args, **kwargs).decode('utf-8')
def check_call(*args, **kwargs):
"""subprocess2.check_call() passing shell=True on Windows for git."""
kwargs.setdefault('shell', NEED_SHELL)
subprocess2.check_call(*args, **kwargs)
def return_code(*args, **kwargs):
"""subprocess2.call() passing shell=True on Windows for git and
subprocess2.DEVNULL for stdout and stderr."""
kwargs.setdefault('shell', NEED_SHELL)
kwargs.setdefault('stdout', subprocess2.DEVNULL)
kwargs.setdefault('stderr', subprocess2.DEVNULL)
return subprocess2.call(*args, **kwargs)
def is_pristine(root):
"""Returns True if a git checkout is pristine."""
# `git rev-parse --verify` has a non-zero return code if the revision
# doesn't exist.
diff_cmd = ['git', 'diff', '--ignore-submodules', 'origin/main']
return (not check_output(diff_cmd, cwd=root).strip() and
not check_output(diff_cmd + ['--cached'], cwd=root).strip())
def get_log_url(upstream_url, head, tot):
"""Returns an URL to read logs via a Web UI if applicable."""
if re.match(r'https://[^/]*\.googlesource\.com/', upstream_url):
# gitiles
return '%s/+log/%s..%s' % (upstream_url, head[:12], tot[:12])
if upstream_url.startswith('https://github.com/'):
upstream_url = upstream_url.rstrip('/')
if upstream_url.endswith('.git'):
upstream_url = upstream_url[:-len('.git')]
return '%s/compare/%s...%s' % (upstream_url, head[:12], tot[:12])
return None
def should_show_log(upstream_url):
"""Returns True if a short log should be included in the tree."""
# Skip logs for very active projects.
if upstream_url.endswith('/v8/v8.git'):
return False
if 'webrtc' in upstream_url:
return False
return True
def gclient(args):
"""Executes gclient with the given args and returns the stdout."""
return check_output([sys.executable, GCLIENT_PATH] + args).strip()
def generate_commit_message(
full_dir, dependency, head, roll_to, no_log, log_limit):
"""Creates the commit message for this specific roll."""
commit_range = '%s..%s' % (head, roll_to)
commit_range_for_header = '%s..%s' % (head[:9], roll_to[:9])
upstream_url = check_output(
['git', 'config', 'remote.origin.url'], cwd=full_dir).strip()
log_url = get_log_url(upstream_url, head, roll_to)
cmd = ['git', 'log', commit_range, '--date=short', '--no-merges']
logs = check_output(
# Args with '=' are automatically quoted.
cmd + ['--format=%ad %ae %s', '--'],
cwd=full_dir).rstrip()
logs = re.sub(r'(?m)^(\d\d\d\d-\d\d-\d\d [^@]+)@[^ ]+( .*)$', r'\1\2', logs)
lines = logs.splitlines()
cleaned_lines = [l for l in lines if not _ROLL_SUBJECT.match(l)]
logs = '\n'.join(cleaned_lines) + '\n'
nb_commits = len(lines)
rolls = nb_commits - len(cleaned_lines)
header = 'Roll %s/ %s (%d commit%s%s)\n\n' % (
dependency,
commit_range_for_header,
nb_commits,
's' if nb_commits > 1 else '',
('; %s trivial rolls' % rolls) if rolls else '')
log_section = ''
if log_url:
log_section = log_url + '\n\n'
log_section += '$ %s ' % ' '.join(cmd)
log_section += '--format=\'%ad %ae %s\'\n'
log_section = log_section.replace(commit_range, commit_range_for_header)
# It is important that --no-log continues to work, as it is used by
# internal -> external rollers. Please do not remove or break it.
if not no_log and should_show_log(upstream_url):
if len(cleaned_lines) > log_limit:
# Keep the first N/2 log entries and last N/2 entries.
lines = logs.splitlines(True)
lines = lines[:log_limit//2] + ['(...)\n'] + lines[-log_limit//2:]
logs = ''.join(lines)
log_section += logs
return header + log_section
def calculate_roll(full_dir, dependency, roll_to):
"""Calculates the roll for a dependency by processing gclient_dict, and
fetching the dependency via git.
"""
head = gclient(['getdep', '-r', dependency])
if not head:
raise Error('%s is unpinned.' % dependency)
check_call(['git', 'fetch', 'origin', '--quiet'], cwd=full_dir)
if roll_to == 'origin/HEAD':
check_output(['git', 'remote', 'set-head', 'origin', '-a'], cwd=full_dir)
roll_to = check_output(['git', 'rev-parse', roll_to], cwd=full_dir).strip()
return head, roll_to
def gen_commit_msg(logs, cmdline, reviewers, bug):
"""Returns the final commit message."""
commit_msg = ''
if len(logs) > 1:
commit_msg = 'Rolling %d dependencies\n\n' % len(logs)
commit_msg += '\n\n'.join(logs)
commit_msg += '\nCreated with:\n ' + cmdline + '\n'
commit_msg += 'R=%s\n' % ','.join(reviewers) if reviewers else ''
commit_msg += '\nBug: %s\n' % bug if bug else ''
return commit_msg
def finalize(commit_msg, current_dir, rolls):
"""Commits changes to the DEPS file, then uploads a CL."""
print('Commit message:')
print('\n'.join(' ' + i for i in commit_msg.splitlines()))
check_call(['git', 'add', 'DEPS'], cwd=current_dir)
check_call(['git', 'commit', '--quiet', '-m', commit_msg], cwd=current_dir)
# Pull the dependency to the right revision. This is surprising to users
# otherwise.
for _head, roll_to, full_dir in sorted(rolls.values()):
check_call(['git', 'checkout', '--quiet', roll_to], cwd=full_dir)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
'--ignore-dirty-tree', action='store_true',
help='Roll anyways, even if there is a diff.')
parser.add_argument(
'-r', '--reviewer',
help='To specify multiple reviewers, use comma separated list, e.g. '
'-r joe,jane,john. Defaults to @chromium.org')
parser.add_argument('-b', '--bug', help='Associate a bug number to the roll')
# It is important that --no-log continues to work, as it is used by
# internal -> external rollers. Please do not remove or break it.
parser.add_argument(
'--no-log', action='store_true',
help='Do not include the short log in the commit message')
parser.add_argument(
'--log-limit', type=int, default=100,
help='Trim log after N commits (default: %(default)s)')
parser.add_argument(
'--roll-to', default='origin/HEAD',
help='Specify the new commit to roll to (default: %(default)s)')
parser.add_argument(
'--key', action='append', default=[],
help='Regex(es) for dependency in DEPS file')
parser.add_argument('dep_path', nargs='+', help='Path(s) to dependency')
args = parser.parse_args()
if len(args.dep_path) > 1:
if args.roll_to != 'origin/HEAD':
parser.error(
'Can\'t use multiple paths to roll simultaneously and --roll-to')
if args.key:
parser.error(
'Can\'t use multiple paths to roll simultaneously and --key')
reviewers = None
if args.reviewer:
reviewers = args.reviewer.split(',')
for i, r in enumerate(reviewers):
if not '@' in r:
reviewers[i] = r + '@chromium.org'
gclient_root = gclient(['root'])
current_dir = os.getcwd()
dependencies = sorted(d.replace('\\', '/').rstrip('/') for d in args.dep_path)
cmdline = 'roll-dep ' + ' '.join(dependencies) + ''.join(
' --key ' + k for k in args.key)
try:
if not args.ignore_dirty_tree and not is_pristine(current_dir):
raise Error(
'Ensure %s is clean first (no non-merged commits).' % current_dir)
# First gather all the information without modifying anything, except for a
# git fetch.
rolls = {}
for dependency in dependencies:
full_dir = os.path.normpath(os.path.join(gclient_root, dependency))
if not os.path.isdir(full_dir):
print('Dependency %s not found at %s' % (dependency, full_dir))
full_dir = os.path.normpath(os.path.join(current_dir, dependency))
print('Will look for relative dependency at %s' % full_dir)
if not os.path.isdir(full_dir):
raise Error('Directory not found: %s (%s)' % (dependency, full_dir))
head, roll_to = calculate_roll(full_dir, dependency, args.roll_to)
if roll_to == head:
if len(dependencies) == 1:
raise AlreadyRolledError('No revision to roll!')
print('%s: Already at latest commit %s' % (dependency, roll_to))
else:
print(
'%s: Rolling from %s to %s' % (dependency, head[:10], roll_to[:10]))
rolls[dependency] = (head, roll_to, full_dir)
logs = []
setdep_args = []
for dependency, (head, roll_to, full_dir) in sorted(rolls.items()):
log = generate_commit_message(
full_dir, dependency, head, roll_to, args.no_log, args.log_limit)
logs.append(log)
setdep_args.extend(['-r', '{}@{}'.format(dependency, roll_to)])
gclient(['setdep'] + setdep_args)
commit_msg = gen_commit_msg(logs, cmdline, reviewers, args.bug)
finalize(commit_msg, current_dir, rolls)
except Error as e:
sys.stderr.write('error: %s\n' % e)
return 2 if isinstance(e, AlreadyRolledError) else 1
except subprocess2.CalledProcessError:
return 1
print('')
if not reviewers:
print('You forgot to pass -r, make sure to insert a R=foo@example.com line')
print('to the commit description before emailing.')
print('')
print('Run:')
print(' git cl upload --send-mail')
return 0
if __name__ == '__main__':
sys.exit(main())
| 35.996656 | 108 | 0.655858 |
ace03bb37e73d37e69f0adf98a1a538e9fb73f72 | 1,367 | py | Python | m_layer/m_layer_test.py | gunpowder78/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | 1 | 2022-03-19T04:26:12.000Z | 2022-03-19T04:26:12.000Z | m_layer/m_layer_test.py | gunpowder78/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | null | null | null | m_layer/m_layer_test.py | gunpowder78/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | 1 | 2022-03-30T07:20:29.000Z | 2022-03-30T07:20:29.000Z | # coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Tests for m_layer.
We test that we can set up a model and run inference.
We are not trying to ensure that training works.
"""
import numpy
import tensorflow as tf
from m_layer import MLayer
class MLayerTest(tf.test.TestCase):
def test_m_layer(self):
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(3,)),
MLayer(dim_m=5, matrix_init='normal'),
tf.keras.layers.ActivityRegularization(l2=1e-4),
tf.keras.layers.Flatten()
])
mlayer = model.layers[1]
self.assertEqual(mlayer.trainable_weights[0].shape, [3, 5, 5])
prediction = model.predict(tf.ones((1, 3)))
self.assertFalse(numpy.isnan(prediction).any())
if __name__ == '__main__':
tf.test.main()
| 29.717391 | 74 | 0.719093 |
ace03c2cb08850ebabb97fd2a9c17f795f1cc780 | 350 | py | Python | kucoin_futures/client.py | cyptotrader/kucoin-futures-python-sdk | ca6df293353123beb453b7fda220ac5717478ec6 | [
"MIT"
] | 25 | 2020-12-18T05:06:34.000Z | 2022-02-23T10:14:31.000Z | kucoin_futures/client.py | cyptotrader/kucoin-futures-python-sdk | ca6df293353123beb453b7fda220ac5717478ec6 | [
"MIT"
] | 13 | 2020-12-28T20:57:29.000Z | 2022-03-22T07:21:38.000Z | kucoin_futures/client.py | cyptotrader/kucoin-futures-python-sdk | ca6df293353123beb453b7fda220ac5717478ec6 | [
"MIT"
] | 18 | 2020-12-01T07:27:56.000Z | 2022-03-24T13:24:49.000Z | from kucoin_futures.marke_data.market_data import MarketData
from kucoin_futures.trade.trade import TradeData
from kucoin_futures.user.user import UserData
from kucoin_futures.ws_token.token import GetToken
class Market(MarketData):
pass
class User(UserData):
pass
class Trade(TradeData):
pass
class WsToken(GetToken):
pass
| 15.217391 | 60 | 0.788571 |
ace03c997a60d146576e0b7ff139705ef5cf75d1 | 6,584 | py | Python | parser/fase2/team29/analizer_pl/modules/code.py | jossiebk/tytus | de6ce433d61609d4eaa5d0dbbd2ce13aaa573544 | [
"MIT"
] | null | null | null | parser/fase2/team29/analizer_pl/modules/code.py | jossiebk/tytus | de6ce433d61609d4eaa5d0dbbd2ce13aaa573544 | [
"MIT"
] | null | null | null | parser/fase2/team29/analizer_pl/modules/code.py | jossiebk/tytus | de6ce433d61609d4eaa5d0dbbd2ce13aaa573544 | [
"MIT"
] | null | null | null | from analizer_pl.C3D.operations import operation
from analizer_pl.C3D.operations import assignment
from analizer_pl.C3D.operations import declaration
from analizer_pl.C3D.operations import block
from analizer_pl.C3D.operations import function
from analizer_pl.C3D.operations import case
from analizer_pl.C3D.operations import return_
from analizer_pl.C3D.operations import if_stmt
from analizer_pl.C3D.operations import else_stmt
from analizer_pl.C3D.operations import elseif_stmt
from analizer_pl.C3D.operations import func_call
from analizer_pl.C3D.operations import execute_
from analizer_pl.C3D.operations import drop_func
from analizer_pl.C3D.operations import datatype
from analizer_pl.sql_statement.create import create_database
from analizer_pl.sql_statement.create import create_index
from analizer_pl.sql_statement.create import create_table
from analizer_pl.sql_statement.create import create_type
from analizer_pl.sql_statement.alter import alter_database
from analizer_pl.sql_statement.alter import alter_index
from analizer_pl.sql_statement.alter import alter_table
from analizer_pl.sql_statement.drop import drop_database
from analizer_pl.sql_statement.drop import drop_table
from analizer_pl.sql_statement.drop import drop_index
from analizer_pl.sql_statement.select import select
from analizer_pl.sql_statement.select import union
from analizer_pl.sql_statement.select import select_first
from analizer_pl.sql_statement import use_
from analizer_pl.sql_statement import show_
from analizer_pl.sql_statement import truncate_
from analizer_pl.sql_statement import insert_
def TernaryOperation(temp, exp1, exp2, exp3, operator, row, column):
return operation.Ternary(temp, exp1, exp2, exp3, operator, row, column)
def BinaryOperation(temp, exp1, exp2, operator, row, column):
return operation.Binary(temp, exp1, exp2, operator, row, column)
def UnaryOperation(temp, exp, operator, row, column):
return operation.Unary(temp, exp, operator, row, column)
def Assignment(id, value, row, column):
return assignment.Assignment(id, value, row, column)
def Declaration(id, type, ass, row, column):
return declaration.Declaration(id, type, ass, row, column)
def Block(function, declaration, blocks, exception, label, row, column):
return block.Block(function, declaration, blocks, exception, label, row, column)
def FunctionDeclaration(proc, id, params, returns, row, column):
return function.FunctionDeclaration(proc, id, params, returns, row, column)
def Case(expBool, blockStmt, elseCase, elseStmt, row, column):
return case.Case(expBool, blockStmt, elseCase, elseStmt, row, column)
def Return(exp, row, column):
return return_.Return(exp, row, column)
def IfStatement(row, column, expBool, elseif_list, else_, stmts):
return if_stmt.If_Statement(row, column, expBool, elseif_list, else_, stmts)
def ElseIfStatement(row, column, expBool, stmt):
return elseif_stmt.ElseIfStmt(row, column, expBool, stmt)
def ElseStatement(row, column, stmt):
return else_stmt.ElseStmt(row, column, stmt)
def CreateDatabase(replace, exists, name, owner, mode, row, column):
return create_database.CreateDatabase(
replace, exists, name, owner, mode, row, column
)
def CreateTable(exists, name, inherits, row, column, columns):
return create_table.CreateTable(exists, name, inherits, row, column, columns)
def CreateType(exists, name, row, column, values):
return create_type.CreateType(exists, name, row, column, values)
def CreateIndex(unique, idIndex, idTable, usingMethod, whereCl, row, column, optList):
return create_index.CreateIndex(
unique, idIndex, idTable, usingMethod, whereCl, row, column, optList
)
def AlterDataBase(option, name, newname, row, column):
return alter_database.AlterDataBase(option, name, newname, row, column)
def AlterTable(table, row, column, params=[]):
return alter_table.AlterTable(table, row, column, params)
def DropDatabase(name, exists, row, column):
return drop_database.DropDatabase(name, exists, row, column)
def DropTable(name, exists, row, column):
return drop_table.DropTable(name, exists, row, column)
def UseDataBase(db, row, column):
return use_.UseDataBase(db, row, column)
def ShowDataBase(like, row, column):
return show_.ShowDataBases(like, row, column)
def Truncate(name, row, column):
return truncate_.Truncate(name, row, column)
def FunctionCall(id, params, isBlock, temp, row, column):
return func_call.FunctionCall(id, params, isBlock, temp, row, column)
def Execute_(procedures, row, column):
return execute_.Execute(procedures, row, column)
def DropFunction(id, row, column):
return drop_func.DropFunction(id, row, column)
def Identifier(id, isBlock, row, column):
return datatype.Identifier(id, isBlock, row, column)
def BinaryExpression(temp, exp1, exp2, operator, isBlock, row, column):
return datatype.BinaryExpression(temp, exp1, exp2, operator, isBlock, row, column)
def UnaryExpression(temp, exp, operator, isBlock, row, column):
return datatype.UnaryExpression(temp, exp, operator, isBlock, row, column)
def DropIndex(exists, idList, row, column):
return drop_index.DropIndex(exists, idList, row, column)
def AlterIndex(exists, idIndex, columnIndex, row, column, idOrNumber=""):
return alter_index.AlterIndex(exists, idIndex, columnIndex, row, column, idOrNumber)
def Insert(tabla, columns, parametros, row, column):
return insert_.InsertInto(tabla, columns, parametros, row, column)
def Select(
distinct, params, fromcl, wherecl, groupbyCl, limitCl, orderByCl, row, column
):
return select.Select(
distinct, params, fromcl, wherecl, groupbyCl, limitCl, orderByCl, row, column
)
def Union(type_, select1, select2, all, row, column):
return union.Select(type_, select1, select2, all, row, column)
def SelectOnlyParams(params, row, column):
return select.SelectOnlyParams(params, row, column)
def SelecctParam(exp, alias, row, column):
return select.SelectParam(exp, alias, row, column)
def TernaryExpression(temp, exp1, exp2, exp3, operator, isBlock, row, column):
return datatype.TernaryExpression(
temp, exp1, exp2, exp3, operator, isBlock, row, column
)
def Aggrupation(exp, isBlock, row, column):
return datatype.Aggrupation(exp, isBlock, row, column)
def SelectFirstValue(temp, select):
return select_first.SelectFirstValue(temp, select)
def SelectOnlyParamsFirst(temp, select):
return select_first.SelectOnlyParamsFirst(temp, select) | 32.756219 | 88 | 0.7702 |
ace03cba9c1228b9adafecf8704f3d037c2a68bd | 2,204 | py | Python | siamese_resnet/utils.py | MFRIbrahim/NN-Playground | 5ca88f1606862fb697cf215336670e8cd942c889 | [
"MIT"
] | null | null | null | siamese_resnet/utils.py | MFRIbrahim/NN-Playground | 5ca88f1606862fb697cf215336670e8cd942c889 | [
"MIT"
] | null | null | null | siamese_resnet/utils.py | MFRIbrahim/NN-Playground | 5ca88f1606862fb697cf215336670e8cd942c889 | [
"MIT"
] | null | null | null | from albumentations.augmentations.transforms import JpegCompression, RandomBrightness
import torch
import torchvision
from torch.utils.data import DataLoader
import albumentations as A
from albumentations.pytorch import ToTensorV2
import config as c
def save_model(model, optimizer, path):
torch.save({
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict()
}, path)
def load_model(model, optimizer, path):
checkpoint = torch.load(path)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
def get_transforms():
train_transform = A.Compose([
A.Resize(height=c.IMAGE_HEIGHT, width=c.IMAGE_WIDTH),
A.GaussNoise(p=1),
# A.HorizontalFlip(p=0.5),
# A.VerticalFlip(p=0.5),
# A.Blur(p=0.5),
# A.RandomGamma(p=0.5),
# A.RandomBrightness(p=0.5),
A.Normalize(
mean=c.CHANNEL_MEANS,
std=c.CHANNEL_STDS,
max_pixel_value=255
),
ToTensorV2(transpose_mask=True)
])
val_transform = A.Compose([
A.Resize(height=c.IMAGE_HEIGHT, width=c.IMAGE_WIDTH),
A.Normalize(
mean=c.CHANNEL_MEANS,
std=c.CHANNEL_STDS,
max_pixel_value=255
),
ToTensorV2(transpose_mask=True)
])
return train_transform, val_transform
def get_loader(dataset):
loader = DataLoader(
dataset,
batch_size=c.VAL_BATCH_SIZE,
shuffle=True,
num_workers=c.N_WORKERS,
pin_memory=c.PIN_MEMORY,
drop_last=True
)
return loader
def get_error(model, loader):
mean_error = 0
model.eval()
with torch.no_grad():
for img_1, img_2, targets in loader:
img_1 = img_1.to(c.DEVICE)
img_2 = img_2.to(c.DEVICE)
targets = targets.to(c.DEVICE)
output = torch.sigmoid(model(img_1, img_2))
output = (output > 0.5).float()
difference = torch.abs(output - targets)
mean_error += (torch.sum(difference) / difference.shape[0]).item()
return mean_error / len(loader)
| 27.898734 | 85 | 0.629764 |
ace03d1deac29f4ca0d2be9f96f17b9ed47d1209 | 321 | py | Python | app/utils/auth.py | san-smith/flask-api-example | 4a5d6e9ef0df6f7a24e6f71a0b38f3f679bbe23d | [
"MIT"
] | null | null | null | app/utils/auth.py | san-smith/flask-api-example | 4a5d6e9ef0df6f7a24e6f71a0b38f3f679bbe23d | [
"MIT"
] | null | null | null | app/utils/auth.py | san-smith/flask-api-example | 4a5d6e9ef0df6f7a24e6f71a0b38f3f679bbe23d | [
"MIT"
] | null | null | null | from app.utils.errors import EntityDoesNotExist
from app.models.domain.user import User
def check_email_is_taken(email: str) -> bool:
try:
user = User.query.filter_by(email=email).first()
if user is None:
return False
except EntityDoesNotExist:
return False
return True
| 22.928571 | 56 | 0.679128 |
ace03d5db3f1a1203b17c8313a97605f4cb6716d | 3,289 | py | Python | tests/emmet-builders/test_summary.py | JaGeo/emmet | db01498d1136fc499961277f0b0edce3b9ddf386 | [
"BSD-3-Clause-LBNL"
] | 19 | 2018-09-26T17:12:35.000Z | 2022-03-19T03:48:04.000Z | tests/emmet-builders/test_summary.py | JaGeo/emmet | db01498d1136fc499961277f0b0edce3b9ddf386 | [
"BSD-3-Clause-LBNL"
] | 273 | 2017-06-15T22:13:07.000Z | 2022-03-29T20:39:55.000Z | tests/emmet-builders/test_summary.py | JaGeo/emmet | db01498d1136fc499961277f0b0edce3b9ddf386 | [
"BSD-3-Clause-LBNL"
] | 38 | 2017-06-13T21:50:00.000Z | 2022-03-26T18:31:21.000Z | from pathlib import Path
import pytest
from maggma.stores import JSONStore, MemoryStore
from monty.serialization import dumpfn, loadfn
from emmet.builders.materials.summary import SummaryBuilder
from emmet.builders.vasp.materials import MaterialsBuilder
@pytest.fixture(scope="session")
def tasks_store(test_dir):
return JSONStore(test_dir / "test_si_tasks.json.gz")
@pytest.fixture(scope="session")
def materials(tasks_store):
materials_store = MemoryStore(key="material_id")
builder = MaterialsBuilder(tasks=tasks_store, materials=materials_store)
builder.run()
return materials_store
@pytest.fixture
def electronic_structure():
return MemoryStore(key="material_id")
@pytest.fixture
def thermo():
return MemoryStore(key="material_id")
@pytest.fixture
def grain_boundaries():
return MemoryStore()
@pytest.fixture
def magnetism():
return MemoryStore()
@pytest.fixture
def elasticity():
return MemoryStore()
@pytest.fixture
def dielectric():
return MemoryStore()
@pytest.fixture
def piezoelectric():
return MemoryStore()
@pytest.fixture
def phonon():
return MemoryStore()
@pytest.fixture
def insertion_electrodes():
return MemoryStore()
@pytest.fixture
def substrates():
return MemoryStore()
@pytest.fixture
def oxi_states():
return MemoryStore()
@pytest.fixture
def surfaces():
return MemoryStore()
@pytest.fixture
def eos():
return MemoryStore()
@pytest.fixture
def xas():
return MemoryStore()
@pytest.fixture
def provenance():
return MemoryStore()
@pytest.fixture
def charge_density_index():
return MemoryStore()
@pytest.fixture
def summary():
return MemoryStore(key="material_id")
def test_summary_builder(
materials,
thermo,
xas,
grain_boundaries,
electronic_structure,
magnetism,
elasticity,
dielectric,
piezoelectric,
phonon,
insertion_electrodes,
substrates,
surfaces,
oxi_states,
eos,
provenance,
charge_density_index,
summary,
):
builder = SummaryBuilder(
materials=materials,
electronic_structure=electronic_structure,
thermo=thermo,
magnetism=magnetism,
dielectric=dielectric,
piezoelectric=piezoelectric,
phonon=phonon,
insertion_electrodes=insertion_electrodes,
elasticity=elasticity,
substrates=substrates,
surfaces=surfaces,
oxi_states=oxi_states,
xas=xas,
grain_boundaries=grain_boundaries,
eos=eos,
provenance=provenance,
charge_density_index=charge_density_index,
summary=summary,
)
builder.run()
assert summary.count() == 1
def test_serialization(tmpdir):
builder = SummaryBuilder(
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
MemoryStore(),
)
dumpfn(builder.as_dict(), Path(tmpdir) / "test.json")
loadfn(Path(tmpdir) / "test.json")
| 18.374302 | 76 | 0.676801 |
ace03df939ac2992002a9c14cce84d1df25a492b | 2,108 | py | Python | pychron/environment/util.py | ael-noblegas/pychron | 6ebbbb1f66a614972b62b7a9be4c784ae61b5d62 | [
"Apache-2.0"
] | 1 | 2019-02-27T21:57:44.000Z | 2019-02-27T21:57:44.000Z | pychron/environment/util.py | ael-noblegas/pychron | 6ebbbb1f66a614972b62b7a9be4c784ae61b5d62 | [
"Apache-2.0"
] | 80 | 2018-07-17T20:10:20.000Z | 2021-08-17T15:38:24.000Z | pychron/environment/util.py | AGESLDEO/pychron | 1a81e05d9fba43b797f335ceff6837c016633bcf | [
"Apache-2.0"
] | null | null | null | # ===============================================================================
# Copyright 2016 ross
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===============================================================================
# ============= enthought library imports =======================
# ============= standard library imports ========================
# ============= local library imports ==========================
from __future__ import absolute_import
from __future__ import print_function
import os
from traits.etsconfig.etsconfig import ETSConfig
from pychron.paths import global_hidden
def get_path(appname):
return os.path.join(global_hidden, '{}.active_env'.format(appname))
def get_environment(appname):
p = get_path(appname)
if os.path.isfile(p):
with open(p, 'r') as rfile:
env = rfile.readline()
return env.strip()
def set_environment(appname, env_path):
p = get_path(appname)
if not os.path.isdir(os.path.dirname(p)):
os.mkdir(os.path.dirname(p))
with open(p, 'w') as wfile:
wfile.write('{}\n'.format(env_path))
set_application_home(appname, env_path)
def set_application_home(appname, env=None):
if env is None:
env = get_environment(appname)
if env:
p = os.path.join(env, '.appdata', appname)
print('setting application home to {}'.format(p))
ETSConfig.application_home = p
if not os.path.exists(ETSConfig.application_home):
os.makedirs(ETSConfig.application_home)
# ============= EOF =============================================
| 32.430769 | 81 | 0.592979 |
ace03e1341ce98104fb8470d8dfa8c20ac269933 | 5,680 | py | Python | src/threadingex/threadpoolexecutor.py | kaleksandrov/python-thread-pool-executor | 53aff7eef61332f9dd94bc18d0f56f16aed894d5 | [
"MIT"
] | 1 | 2015-12-15T06:50:14.000Z | 2015-12-15T06:50:14.000Z | src/threadingex/threadpoolexecutor.py | kaleksandrov/python-thread-pool-executor | 53aff7eef61332f9dd94bc18d0f56f16aed894d5 | [
"MIT"
] | null | null | null | src/threadingex/threadpoolexecutor.py | kaleksandrov/python-thread-pool-executor | 53aff7eef61332f9dd94bc18d0f56f16aed894d5 | [
"MIT"
] | 1 | 2021-08-25T13:15:44.000Z | 2021-08-25T13:15:44.000Z | #!/usr/bin/env python
import logging
import os
from Queue import Queue
from threading import Thread, Condition
DEFAULT_NUMBER_OF_THREADS = 8
def get_number_of_cpus():
"""
Retrieves the number ot the available processors/cores/threads that can be used.
Uses the API from the os package. If this information cannot be retrieved,
returns the default value stored in DEFAULT_NUMBER_OF_THREADS constant.
:return: The number of available processors/cores/threads.
"""
try:
return os.sysconf("SC_NPROCESSORS_ONLN")
except Exception:
return DEFAULT_NUMBER_OF_THREADS
class ThreadPoolExecutorState(object):
"""
Represents the different states of the ThreadPoolExecutor class.
"""
NOT_STARTED = 1
RUNNING = 2
STOPPING = 3
STOPPED = 4
class ThreadPoolExecutor(object):
"""
Creates a pool of thread that can be reused for multiple tasks. The tasks are submitted to the executor
and it is responsible to deliver them to the working threads. The API allows its client to block until
the task execution completes or to continue its work while the threads are doing their job in the background.
A simple example of usage is as follows:
def task1(value):
...
def task2(value):
...
executor = ThreadPoolExecutor(16)
executor.start()
...
executor.submit(task1, value1)
executor.submit(task1, value2)
executor.submit(task2, value3)
executor.submit(task2, value4)
...
executor.shutdown(True)
"""
def __init__(self, size=get_number_of_cpus()):
self._queue = Queue()
self._size = size
self._pool = []
self._lock = Condition()
self._state = ThreadPoolExecutorState.NOT_STARTED
def execute_task():
while True:
with self._lock:
if self._state == ThreadPoolExecutorState.RUNNING:
if not self._queue.empty():
task, args = self._queue.get(False)
else:
logging.debug('Start waiting...')
self._lock.wait()
continue
elif self._state == ThreadPoolExecutorState.STOPPING:
if not self._queue.empty():
task, args = self._queue.get(False)
else:
break
elif self._state == ThreadPoolExecutorState.STOPPED:
break
else:
raise ValueError('Unknown state: %s', self._state)
if task:
try:
task(*args)
except Exception, ex:
logging.error('Error while executing task in the thread pool.')
logging.exception(ex)
logging.debug('Finished!')
for _ in range(size):
thread = Thread(target=execute_task)
thread.daemon = True
self._pool.append(thread)
def start(self):
"""
Starts the executor by spawning the needed threads.
"""
with self._lock:
self._validate_state(ThreadPoolExecutorState.NOT_STARTED)
self._state = ThreadPoolExecutorState.RUNNING
logging.debug('Spawning %s thread...', self._size)
for thread in self._pool:
thread.start()
def shutdown(self, blocking=True):
"""
Stops the executor. Stopping does not happen immediately, the worker threads will execute all the tasks
from the queue before stopping. The client can choose if to wait the stopping process to finish or
to allow this to happen in the background.
:param blocking: If should wait for the stopping process to finish by blocking the current thread.
"""
with self._lock:
self._validate_state(ThreadPoolExecutorState.RUNNING)
self._state = ThreadPoolExecutorState.STOPPING
logging.debug('Notify waiting threads')
self._lock.notifyAll()
logging.debug('Threads notified')
if blocking:
self._wait_threads_to_finish()
else:
wait_thread = Thread(target=self._wait_threads_to_finish())
wait_thread.start()
def _wait_threads_to_finish(self):
"""
Joins the worker threads to the current one and afther they finish changes the state
of the executor.
"""
for thread in self._pool:
logging.debug('Joining thread %s', thread)
thread.join()
with self._lock:
self._state = ThreadPoolExecutorState.STOPPED
def submit(self, task, *args):
"""
Submits a new task to the executor. The task should be callable and may take unnamed arguments
:param task: The task to be executed.
:param args: The parameters to be passed to the task in the moment of execution.
"""
with self._lock:
self._validate_state(ThreadPoolExecutorState.NOT_STARTED, ThreadPoolExecutorState.RUNNING)
self._queue.put((task, args), False)
self._lock.notify()
def _validate_state(self, *states):
"""
Validates if the current executor's state is in the given ones. If not, raise a ValueError.
:param states: The set of state to check for.
"""
if self._state not in states:
raise ValueError('Invalid state: %s' % self._state)
| 34.634146 | 113 | 0.592606 |
ace03e3d1b190d3103c6584040d5110f90a94ed0 | 14,674 | py | Python | tensorflow/python/lib/io/file_io.py | AlexChrisF/udacity | b7f85a74058fc63ccb7601c418450ab934ef5953 | [
"Apache-2.0"
] | 44 | 2017-01-26T11:39:36.000Z | 2019-06-28T10:03:19.000Z | tensorflow/python/lib/io/file_io.py | AlexChrisF/udacity | b7f85a74058fc63ccb7601c418450ab934ef5953 | [
"Apache-2.0"
] | 7 | 2017-07-13T09:40:59.000Z | 2019-04-08T22:46:51.000Z | tensorflow/python/lib/io/file_io.py | AlexChrisF/udacity | b7f85a74058fc63ccb7601c418450ab934ef5953 | [
"Apache-2.0"
] | 11 | 2017-08-17T05:52:35.000Z | 2021-06-19T04:39:45.000Z | # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""File IO methods that wrap the C++ FileSystem API.
The C++ FileSystem API is SWIG wrapped in file_io.i. These functions call those
to accomplish basic File IO operations.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import uuid
from tensorflow.python import pywrap_tensorflow
from tensorflow.python.framework import errors
from tensorflow.python.util import compat
class FileIO(object):
"""FileIO class that exposes methods to read / write to / from files.
The constructor takes the following arguments:
name: name of the file
mode: one of 'r', 'w', 'a', 'r+', 'w+', 'a+'. Append 'b' for bytes mode.
Can be used as an iterator to iterate over lines in the file.
The default buffer size used for the BufferedInputStream used for reading
the file line by line is 1024 * 512 bytes.
"""
def __init__(self, name, mode):
self.__name = name
self.__mode = mode
self._read_buf = None
self._writable_file = None
self._binary_mode = "b" in mode
mode = mode.replace("b", "")
if mode not in ("r", "w", "a", "r+", "w+", "a+"):
raise errors.InvalidArgumentError(
None, None, "mode is not 'r' or 'w' or 'a' or 'r+' or 'w+' or 'a+'")
self._read_check_passed = mode in ("r", "r+", "a+", "w+")
self._write_check_passed = mode in ("a", "w", "r+", "a+", "w+")
@property
def name(self):
"""Returns the file name."""
return self.__name
@property
def mode(self):
"""Returns the mode in which the file was opened."""
return self.__mode
def _preread_check(self):
if not self._read_buf:
if not self._read_check_passed:
raise errors.PermissionDeniedError(None, None,
"File isn't open for reading")
with errors.raise_exception_on_not_ok_status() as status:
self._read_buf = pywrap_tensorflow.CreateBufferedInputStream(
compat.as_bytes(self.__name), 1024 * 512, status)
def _prewrite_check(self):
if not self._writable_file:
if not self._write_check_passed:
raise errors.PermissionDeniedError(None, None,
"File isn't open for writing")
with errors.raise_exception_on_not_ok_status() as status:
self._writable_file = pywrap_tensorflow.CreateWritableFile(
compat.as_bytes(self.__name), compat.as_bytes(self.__mode), status)
def _prepare_value(self, val):
if self._binary_mode:
return compat.as_bytes(val)
else:
return compat.as_str_any(val)
def size(self):
"""Returns the size of the file."""
return stat(self.__name).length
def write(self, file_content):
"""Writes file_content to the file. Appends to the end of the file."""
self._prewrite_check()
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.AppendToFile(
compat.as_bytes(file_content), self._writable_file, status)
def read(self, n=-1):
"""Returns the contents of a file as a string.
Starts reading from current position in file.
Args:
n: Read 'n' bytes if n != -1. If n = -1, reads to end of file.
Returns:
'n' bytes of the file (or whole file) in bytes mode or 'n' bytes of the
string if in string (regular) mode.
"""
self._preread_check()
with errors.raise_exception_on_not_ok_status() as status:
if n == -1:
length = self.size() - self.tell()
else:
length = n
return self._prepare_value(
pywrap_tensorflow.ReadFromStream(self._read_buf, length, status))
def seek(self, position):
"""Seeks to the position in the file."""
self._preread_check()
with errors.raise_exception_on_not_ok_status() as status:
ret_status = self._read_buf.Seek(position)
pywrap_tensorflow.Set_TF_Status_from_Status(status, ret_status)
def readline(self):
r"""Reads the next line from the file. Leaves the '\n' at the end."""
self._preread_check()
return self._prepare_value(self._read_buf.ReadLineAsString())
def readlines(self):
"""Returns all lines from the file in a list."""
self._preread_check()
lines = []
while True:
s = self.readline()
if not s:
break
lines.append(s)
return lines
def tell(self):
"""Returns the current position in the file."""
self._preread_check()
return self._read_buf.Tell()
def __enter__(self):
"""Make usable with "with" statement."""
return self
def __exit__(self, unused_type, unused_value, unused_traceback):
"""Make usable with "with" statement."""
self.close()
def __iter__(self):
return self
def next(self):
retval = self.readline()
if not retval:
raise StopIteration()
return retval
def __next__(self):
return self.next()
def flush(self):
"""Flushes the Writable file.
This only ensures that the data has made its way out of the process without
any guarantees on whether it's written to disk. This means that the
data would survive an application crash but not necessarily an OS crash.
"""
if self._writable_file:
with errors.raise_exception_on_not_ok_status() as status:
ret_status = self._writable_file.Flush()
pywrap_tensorflow.Set_TF_Status_from_Status(status, ret_status)
def close(self):
"""Closes FileIO. Should be called for the WritableFile to be flushed."""
self._read_buf = None
if self._writable_file:
with errors.raise_exception_on_not_ok_status() as status:
ret_status = self._writable_file.Close()
pywrap_tensorflow.Set_TF_Status_from_Status(status, ret_status)
self._writable_file = None
def file_exists(filename):
"""Determines whether a path exists or not.
Args:
filename: string, a path
Returns:
True if the path exists, whether its a file or a directory.
False if the path does not exist and there are no filesystem errors.
Raises:
errors.OpError: Propagates any errors reported by the FileSystem API.
"""
try:
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.FileExists(compat.as_bytes(filename), status)
except errors.NotFoundError:
return False
return True
def delete_file(filename):
"""Deletes the file located at 'filename'.
Args:
filename: string, a filename
Raises:
errors.OpError: Propagates any errors reported by the FileSystem API. E.g.,
NotFoundError if the file does not exist.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.DeleteFile(compat.as_bytes(filename), status)
def read_file_to_string(filename, binary_mode=False):
"""Reads the entire contents of a file to a string.
Args:
filename: string, path to a file
binary_mode: whether to open the file in binary mode or not. This changes
the type of the object returned.
Returns:
contents of the file as a string or bytes.
Raises:
errors.OpError: Raises variety of errors that are subtypes e.g.
NotFoundError etc.
"""
if binary_mode:
f = FileIO(filename, mode="rb")
else:
f = FileIO(filename, mode="r")
return f.read()
def write_string_to_file(filename, file_content):
"""Writes a string to a given file.
Args:
filename: string, path to a file
file_content: string, contents that need to be written to the file
Raises:
errors.OpError: If there are errors during the operation.
"""
with FileIO(filename, mode="w") as f:
f.write(file_content)
def get_matching_files(filename):
"""Returns a list of files that match the given pattern.
Args:
filename: string, the pattern
Returns:
Returns a list of strings containing filenames that match the given pattern.
Raises:
errors.OpError: If there are filesystem / directory listing errors.
"""
with errors.raise_exception_on_not_ok_status() as status:
# Convert each element to string, since the return values of the
# vector of string should be interpreted as strings, not bytes.
return [compat.as_str_any(matching_filename)
for matching_filename in pywrap_tensorflow.GetMatchingFiles(
compat.as_bytes(filename), status)]
def create_dir(dirname):
"""Creates a directory with the name 'dirname'.
Args:
dirname: string, name of the directory to be created
Notes:
The parent directories need to exist. Use recursive_create_dir instead if
there is the possibility that the parent dirs don't exist.
Raises:
errors.OpError: If the operation fails.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.CreateDir(compat.as_bytes(dirname), status)
def recursive_create_dir(dirname):
"""Creates a directory and all parent/intermediate directories.
It succeeds if dirname already exists and is writable.
Args:
dirname: string, name of the directory to be created
Raises:
errors.OpError: If the operation fails.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.RecursivelyCreateDir(compat.as_bytes(dirname), status)
def copy(oldpath, newpath, overwrite=False):
"""Copies data from oldpath to newpath.
Args:
oldpath: string, name of the file who's contents need to be copied
newpath: string, name of the file to which to copy to
overwrite: boolean, if false its an error for newpath to be occupied by an
existing file.
Raises:
errors.OpError: If the operation fails.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.CopyFile(
compat.as_bytes(oldpath), compat.as_bytes(newpath), overwrite, status)
def rename(oldname, newname, overwrite=False):
"""Rename or move a file / directory.
Args:
oldname: string, pathname for a file
newname: string, pathname to which the file needs to be moved
overwrite: boolean, if false its an error for newpath to be occupied by an
existing file.
Raises:
errors.OpError: If the operation fails.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.RenameFile(
compat.as_bytes(oldname), compat.as_bytes(newname), overwrite, status)
def atomic_write_string_to_file(filename, contents):
"""Writes to `filename` atomically.
This means that when `filename` appears in the filesystem, it will contain
all of `contents`. With write_string_to_file, it is possible for the file
to appear in the filesystem with `contents` only partially written.
Accomplished by writing to a temp file and then renaming it.
Args:
filename: string, pathname for a file
contents: string, contents that need to be written to the file
"""
temp_pathname = filename + ".tmp" + uuid.uuid4().hex
write_string_to_file(temp_pathname, contents)
rename(temp_pathname, filename, overwrite=True)
def delete_recursively(dirname):
"""Deletes everything under dirname recursively.
Args:
dirname: string, a path to a directory
Raises:
errors.OpError: If the operation fails.
"""
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.DeleteRecursively(compat.as_bytes(dirname), status)
def is_directory(dirname):
"""Returns whether the path is a directory or not.
Args:
dirname: string, path to a potential directory
Returns:
True, if the path is a directory; False otherwise
"""
try:
status = pywrap_tensorflow.TF_NewStatus()
return pywrap_tensorflow.IsDirectory(compat.as_bytes(dirname), status)
finally:
pywrap_tensorflow.TF_DeleteStatus(status)
def list_directory(dirname):
"""Returns a list of entries contained within a directory.
The list is in arbitrary order. It does not contain the special entries "."
and "..".
Args:
dirname: string, path to a directory
Returns:
[filename1, filename2, ... filenameN] as strings
Raises:
errors.NotFoundError if directory doesn't exist
"""
if not is_directory(dirname):
raise errors.NotFoundError(None, None, "Could not find directory")
with errors.raise_exception_on_not_ok_status() as status:
# Convert each element to string, since the return values of the
# vector of string should be interpreted as strings, not bytes.
return [
compat.as_str_any(filename)
for filename in pywrap_tensorflow.GetChildren(
compat.as_bytes(dirname), status)
]
def walk(top, in_order=True):
"""Recursive directory tree generator for directories.
Args:
top: string, a Directory name
in_order: bool, Traverse in order if True, post order if False.
Errors that happen while listing directories are ignored.
Yields:
Each yield is a 3-tuple: the pathname of a directory, followed by lists of
all its subdirectories and leaf files.
(dirname, [subdirname, subdirname, ...], [filename, filename, ...])
as strings
"""
top = compat.as_str_any(top)
try:
listing = list_directory(top)
except errors.NotFoundError:
return
files = []
subdirs = []
for item in listing:
full_path = os.path.join(top, item)
if is_directory(full_path):
subdirs.append(item)
else:
files.append(item)
here = (top, subdirs, files)
if in_order:
yield here
for subdir in subdirs:
for subitem in walk(os.path.join(top, subdir), in_order):
yield subitem
if not in_order:
yield here
def stat(filename):
"""Returns file statistics for a given path.
Args:
filename: string, path to a file
Returns:
FileStatistics struct that contains information about the path
Raises:
errors.OpError: If the operation fails.
"""
file_statistics = pywrap_tensorflow.FileStatistics()
with errors.raise_exception_on_not_ok_status() as status:
pywrap_tensorflow.Stat(compat.as_bytes(filename), file_statistics, status)
return file_statistics
| 30.318182 | 80 | 0.699537 |
ace03ee4d47a4a8997818c853d82b67dec83258e | 915 | py | Python | bot/db.py | Aslanyan94/guess_music_bot | c7fb6e538051bc06490b0230c1180ca01fea4eee | [
"MIT"
] | null | null | null | bot/db.py | Aslanyan94/guess_music_bot | c7fb6e538051bc06490b0230c1180ca01fea4eee | [
"MIT"
] | null | null | null | bot/db.py | Aslanyan94/guess_music_bot | c7fb6e538051bc06490b0230c1180ca01fea4eee | [
"MIT"
] | null | null | null | import sqlite3
conn = sqlite3.connect("data.db")
cur = conn.cursor()
cur.execute("""CREATE TABLE music(
id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,
file_id TEXT NOT NULL,
right_answer TEXT NOT NULL,
wrong_answer TEXT NOT NULL
);""")
cur.execute("""INSERT INTO music(id, file_id, right_answer, wrong_answer) VALUES(1, "AwADAgAD0wQAApksWEnLrhR2vZGPVBYE",
"Rihanna-Diamond", "Rihanna-What's My Name,Rihanna-Umbrella,Shakira-Blame,Birdy-Wings"),
(2, "AwADAgAD9gUAAiEWWEmof4jfR5QoARYE", "Shakira-Hips Don't Lie", "Rihanna-Cry,Shakira-La La La,Birdy-Skinny Love"),
(3, "AwADAgADGQYAAnEwWEkO7T1XsMdvcBYE", "Nemra-Born in 94", "Scorpions-White Dove,System Of A Down-Toxicity,Scorpions-Wind Of Chang"),
(4, "AwADAgAD-AUAAiEWWEmnDINxWgqC7BYE", "Mani Beats-N&N", "Grace - You Don't Own Me,Shakira-Loca,Rihanna-Work");""")
conn.commit()
conn.close()
| 41.590909 | 142 | 0.698361 |
ace040d81534f5e835299ca799742ab1ebbed5c7 | 1,267 | py | Python | regress/sys/netinet6/nd6/nd6_dad.py | ArrogantWombatics/openbsd-src | 75721e1d44322953075b7c4b89337b163a395291 | [
"BSD-3-Clause"
] | 1 | 2019-02-16T13:29:23.000Z | 2019-02-16T13:29:23.000Z | regress/sys/netinet6/nd6/nd6_dad.py | ArrogantWombatics/openbsd-src | 75721e1d44322953075b7c4b89337b163a395291 | [
"BSD-3-Clause"
] | 1 | 2018-08-21T03:56:33.000Z | 2018-08-21T03:56:33.000Z | regress/sys/netinet6/nd6/nd6_dad.py | ArrogantWombatics/openbsd-src | 75721e1d44322953075b7c4b89337b163a395291 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/local/bin/python2.7
# send Duplicate Address Detection neighbor solicitation
# expect an neighbor advertisement answer and check it
import os
from addr import *
from scapy.all import *
# link-local solicited-node multicast address
def nsma(a):
n = inet_pton(socket.AF_INET6, a)
return inet_ntop(socket.AF_INET6, in6_getnsma(n))
# ethernet multicast address of multicast address
def nsmac(a):
n = inet_pton(socket.AF_INET6, a)
return in6_getnsmac(n)
# ethernet multicast address of solicited-node multicast address
def nsmamac(a):
return nsmac(nsma(a))
# link-local address
def lla(m):
return "fe80::"+in6_mactoifaceid(m)
ip=IPv6(src="::", dst=nsma(DST_IN6))/ICMPv6ND_NS(tgt=DST_IN6)
eth=Ether(src=SRC_MAC, dst=nsmamac(DST_IN6))/ip
if os.fork() == 0:
time.sleep(1)
sendp(eth, iface=SRC_IF)
os._exit(0)
ans=sniff(iface=SRC_IF, timeout=3, filter=
"ip6 and src "+lla(DST_MAC)+" and dst ff02::1 and icmp6")
for a in ans:
if a and a.type == ETH_P_IPV6 and \
ipv6nh[a.payload.nh] == 'ICMPv6' and \
icmp6types[a.payload.payload.type] == 'Neighbor Advertisement':
tgt=a.payload.payload.tgt
print "target=%s" % (tgt)
if tgt == DST_IN6:
exit(0)
print "TARGET!=%s" % (DST_IN6)
exit(1)
print "NO NEIGHBOR ADVERTISEMENT"
exit(2)
| 25.857143 | 68 | 0.716654 |
ace041f760cc549834101fff690bba609e3e6692 | 31,108 | py | Python | tests/test_repros.py | jroesch/torchdynamo | 0b1e34d53f53937b3066e61a14d210365a24b156 | [
"BSD-3-Clause"
] | null | null | null | tests/test_repros.py | jroesch/torchdynamo | 0b1e34d53f53937b3066e61a14d210365a24b156 | [
"BSD-3-Clause"
] | null | null | null | tests/test_repros.py | jroesch/torchdynamo | 0b1e34d53f53937b3066e61a14d210365a24b156 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env pytest
import collections
import copy
import inspect
from collections import namedtuple
from copy import deepcopy
from typing import List
import torch
from torch.nn import functional as F
import torchdynamo.testing
import torchdynamo.utils
from torchdynamo.testing import requires_static_shapes
from torchdynamo.testing import same
def ifdyn(count1, count2):
if torchdynamo.config.dynamic_shapes:
return count1
else:
return count2
def _do_paste_mask(masks, boxes, img_h: int, img_w: int, skip_empty: bool = True):
# from detectron2 mask_ops.py
device = masks.device
if skip_empty and not torch.jit.is_scripting():
x0_int, y0_int = torch.clamp(boxes.min(dim=0).values.floor()[:2] - 1, min=0).to(
dtype=torch.int32
)
x1_int = torch.clamp(boxes[:, 2].max().ceil() + 1, max=img_w).to(
dtype=torch.int32
)
y1_int = torch.clamp(boxes[:, 3].max().ceil() + 1, max=img_h).to(
dtype=torch.int32
)
else:
x0_int, y0_int = 0, 0
x1_int, y1_int = img_w, img_h
x0, y0, x1, y1 = torch.split(boxes, 1, dim=1) # each is Nx1
N = masks.shape[0]
img_y = torch.arange(y0_int, y1_int, device=device, dtype=torch.float32) + 0.5
img_x = torch.arange(x0_int, x1_int, device=device, dtype=torch.float32) + 0.5
img_y = (img_y - y0) / (y1 - y0) * 2 - 1
img_x = (img_x - x0) / (x1 - x0) * 2 - 1
# img_x, img_y have shapes (N, w), (N, h)
gx = img_x[:, None, :].expand(N, img_y.size(1), img_x.size(1))
gy = img_y[:, :, None].expand(N, img_y.size(1), img_x.size(1))
grid = torch.stack([gx, gy], dim=3)
if not torch.jit.is_scripting():
if not masks.dtype.is_floating_point:
masks = masks.float()
img_masks = F.grid_sample(masks, grid.to(masks.dtype), align_corners=False)
if skip_empty and not torch.jit.is_scripting():
return img_masks[:, 0], (slice(y0_int, y1_int), slice(x0_int, x1_int))
else:
return img_masks[:, 0], ()
def cat(tensors, dim=0):
# from detectron2 wrappers.py
assert isinstance(tensors, (list, tuple))
if len(tensors) == 1:
return tensors[0]
return torch.cat(tensors, dim)
def shapes_to_tensor(x, device=None):
# from detectron2 wrappers.py
if torch.jit.is_scripting():
return torch.as_tensor(x, device=device)
if torch.jit.is_tracing():
assert all(
[isinstance(t, torch.Tensor) for t in x]
), "Shape should be tensor during tracing!"
# as_tensor should not be used in tracing because it records a constant
ret = torch.stack(x)
if ret.device != device: # avoid recording a hard-coded device if not necessary
ret = ret.to(device=device)
return ret
return torch.as_tensor(x, device=device)
class Boxes:
# from detectron2 poolers.py
def __init__(self, tensor: torch.Tensor):
"""
Args:
tensor (Tensor[float]): a Nx4 matrix. Each row is (x1, y1, x2, y2).
"""
device = (
tensor.device if isinstance(tensor, torch.Tensor) else torch.device("cpu")
)
tensor = torch.as_tensor(tensor, dtype=torch.float32, device=device)
if tensor.numel() == 0:
# Use reshape, so we don't end up creating a new tensor that does not depend on
# the inputs (and consequently confuses jit)
tensor = tensor.reshape((-1, 4)).to(dtype=torch.float32, device=device)
assert tensor.dim() == 2 and tensor.size(-1) == 4, tensor.size()
self.tensor = tensor
def __len__(self) -> int:
return self.tensor.shape[0]
@property
def device(self):
return self.tensor.device
def convert_boxes_to_pooler_format(box_lists):
# from detectron2 structures.py
boxes = torch.cat([x.tensor for x in box_lists], dim=0)
# __len__ returns Tensor in tracing.
sizes = shapes_to_tensor([x.__len__() for x in box_lists], device=boxes.device)
indices = torch.repeat_interleave(
torch.arange(len(box_lists), dtype=boxes.dtype, device=boxes.device), sizes
)
return cat([indices[:, None], boxes], dim=1)
ReformerBackwardOutput = namedtuple(
"ReformerBackwardOutput",
["attn_output", "hidden_states", "grad_attn_output", "grad_hidden_states"],
)
ReformerEncoderOutput = namedtuple(
"ReformerEncoderOutput",
["hidden_states", "all_hidden_states", "all_attentions", "past_buckets_states"],
)
class _ReversibleFunction(torch.autograd.Function):
# taken from modeling_reformer.py in huggingface
@staticmethod
def forward(
ctx,
hidden_states,
layers,
attention_mask,
head_mask,
num_hashes,
all_hidden_states,
all_attentions,
past_buckets_states,
use_cache,
orig_sequence_length,
output_hidden_states,
output_attentions,
):
all_buckets = ()
# split duplicated tensor
hidden_states, attn_output = torch.chunk(hidden_states, 2, dim=-1)
for layer_id, (layer, layer_head_mask) in enumerate(zip(layers, head_mask)):
if output_hidden_states is True:
all_hidden_states.append(hidden_states)
attn_output = layer(attn_output)
# Add last layer
if output_hidden_states is True:
all_hidden_states.append(hidden_states)
# attach params to ctx for backward
ctx.save_for_backward(attn_output.detach(), hidden_states.detach())
ctx.layers = layers
ctx.all_buckets = all_buckets
ctx.head_mask = head_mask
ctx.attention_mask = attention_mask
# Concatenate 2 RevNet outputs
return torch.cat([attn_output, hidden_states], dim=-1)
@staticmethod
def backward(ctx, grad_hidden_states):
grad_attn_output, grad_hidden_states = torch.chunk(
grad_hidden_states, 2, dim=-1
)
# retrieve params from ctx for backward
attn_output, hidden_states = ctx.saved_tensors
# create tuple
output = ReformerBackwardOutput(
attn_output=attn_output,
hidden_states=hidden_states,
grad_attn_output=grad_attn_output,
grad_hidden_states=grad_hidden_states,
)
# free memory
del grad_attn_output, grad_hidden_states, attn_output, hidden_states
layers = ctx.layers
all_buckets = ctx.all_buckets
head_mask = ctx.head_mask
attention_mask = ctx.attention_mask
for idx, layer in enumerate(layers[::-1]):
# pop last buckets from stack
buckets = all_buckets[-1]
all_buckets = all_buckets[:-1]
# backprop
output = layer.backward_pass(
next_attn_output=output.attn_output,
hidden_states=output.hidden_states,
grad_attn_output=output.grad_attn_output,
grad_hidden_states=output.grad_hidden_states,
head_mask=head_mask[len(layers) - idx - 1],
attention_mask=attention_mask,
buckets=buckets,
)
assert all_buckets == (), "buckets have to be empty after backpropagation"
grad_hidden_states = torch.cat(
[output.grad_attn_output, output.grad_hidden_states], dim=-1
)
# num of return vars has to match num of forward() args
# return gradient for hidden_states arg and None for other args
return (
grad_hidden_states,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
None,
)
class ReformerEncoder(torch.nn.Module):
def __init__(self):
super().__init__()
self.dropout = 0.5
self.layer_norm = torch.nn.LayerNorm(512, eps=1.0e-12)
self.layers = [torch.nn.Linear(256, 256)]
def forward(
self,
hidden_states,
attention_mask=None,
head_mask=[None] * 6,
num_hashes=None,
use_cache=False,
orig_sequence_length=64,
output_hidden_states=False,
output_attentions=False,
):
# hidden_states and attention lists to be filled if wished
all_hidden_states = []
all_attentions = []
past_buckets_states = [((None), (None)) for i in range(len(self.layers))]
# concat same tensor for reversible ResNet
hidden_states = torch.cat([hidden_states, hidden_states], dim=-1)
hidden_states = _ReversibleFunction.apply(
hidden_states,
self.layers,
attention_mask,
head_mask,
num_hashes,
all_hidden_states,
all_attentions,
past_buckets_states,
use_cache,
orig_sequence_length,
output_hidden_states,
output_attentions,
)
# Apply layer norm to concatenated hidden states
hidden_states = self.layer_norm(hidden_states)
# Apply dropout
hidden_states = torch.nn.functional.dropout(
hidden_states, p=self.dropout, training=self.training
)
return ReformerEncoderOutput(
hidden_states=hidden_states,
all_hidden_states=all_hidden_states,
all_attentions=all_attentions,
past_buckets_states=past_buckets_states,
)
def longformer_chunk(hidden_states, window_overlap=256):
"""convert into overlapping chunks. Chunk size = 2w, overlap size = w"""
# non-overlapping chunks of size = 2w
hidden_states = hidden_states.view(
hidden_states.size(0),
hidden_states.size(1) // (window_overlap * 2),
window_overlap * 2,
hidden_states.size(2),
)
# use `as_strided` to make the chunks overlap with an overlap size = window_overlap
chunk_size = list(hidden_states.size())
chunk_size[1] = chunk_size[1] * 2 - 1
chunk_stride = list(hidden_states.stride())
chunk_stride[1] = chunk_stride[1] // 2
return hidden_states.as_strided(size=chunk_size, stride=chunk_stride)
class PartialT5(torch.nn.Module):
# Highly simplified T5Attention prefix
def __init__(self):
super(PartialT5, self).__init__()
self.q = torch.nn.Linear(512, 512)
self.k = torch.nn.Linear(512, 512)
self.v = torch.nn.Linear(512, 512)
def forward(
self,
hidden_states,
key_value_states=None,
past_key_value=None,
query_length=None,
):
batch_size, seq_length = hidden_states.shape[:2]
real_seq_length = seq_length
if past_key_value is not None:
assert (
len(past_key_value) == 2
), f"past_key_value should have 2 past states: keys and values. Got { len(past_key_value)} past states"
real_seq_length += (
past_key_value[0].shape[2] if query_length is None else query_length
)
def shape(states):
"""projection"""
return states.view(batch_size, -1, 8, 64).transpose(1, 2)
def project(hidden_states, proj_layer, key_value_states, past_key_value):
"""projects hidden states correctly to key/query states"""
if key_value_states is None:
# self-attn
# (batch_size, n_heads, seq_length, dim_per_head)
hidden_states = shape(proj_layer(hidden_states))
elif past_key_value is None:
# cross-attn
# (batch_size, n_heads, seq_length, dim_per_head)
hidden_states = shape(proj_layer(key_value_states))
if past_key_value is not None:
if key_value_states is None:
# self-attn
# (batch_size, n_heads, key_length, dim_per_head)
hidden_states = torch.cat([past_key_value, hidden_states], dim=2)
else:
# cross-attn
hidden_states = past_key_value
return hidden_states
# get query states
query_states = shape(
self.q(hidden_states)
) # (batch_size, n_heads, seq_length, dim_per_head)
# get key/value states
key_states = project(
hidden_states,
self.k,
key_value_states,
past_key_value[0] if past_key_value is not None else None,
)
value_states = project(
hidden_states,
self.v,
key_value_states,
past_key_value[1] if past_key_value is not None else None,
)
# compute scores
scores = torch.matmul(query_states, key_states.transpose(3, 2))
# (truncated here )
return scores, value_states
class ChunkReformerFeedForward(torch.nn.Module):
# simplified from HF modeling_reformer.py
def __init__(self):
super().__init__()
self.layer_norm = torch.nn.LayerNorm(256, eps=1e-12)
self.dense = torch.nn.Linear(256, 256)
self.output = torch.nn.Linear(256, 256)
def forward(self, attention_output):
return apply_chunking_to_forward(
self.forward_chunk,
attention_output + 1,
)
def forward_chunk(self, hidden_states):
hidden_states = self.layer_norm(hidden_states)
hidden_states = self.dense(hidden_states)
return self.output(hidden_states)
def apply_chunking_to_forward(forward_fn, *input_tensors):
# simplified from HF model_utils.py
assert len(input_tensors) > 0
tensor_shape = input_tensors[0].shape[1]
assert all(input_tensor.shape[1] == tensor_shape for input_tensor in input_tensors)
num_args_in_forward_chunk_fn = len(inspect.signature(forward_fn).parameters)
if num_args_in_forward_chunk_fn != len(input_tensors):
raise ValueError()
return forward_fn(*input_tensors)
class FakeMamlInner(torch.nn.Module):
def __init__(self):
super(FakeMamlInner, self).__init__()
self.linear = torch.nn.Linear(784, 5)
def forward(self, x, ignored=None, bn_training=False):
return self.linear(x.view(x.shape[0], -1))
class PartialMaml(torch.nn.Module):
# Highly simplified version of maml.meta.Meta.finetuning
def __init__(self):
super(PartialMaml, self).__init__()
self.net = FakeMamlInner()
self.update_step_test = 10
self.update_lr = 0.4
def forward(self, x_spt, y_spt, x_qry, y_qry):
querysz = x_qry.size(0)
corrects = [0 for _ in range(self.update_step_test + 1)]
# in order to not ruin the state of running_mean/variance and bn_weight/bias
# we finetunning on the copied model instead of self.net
net = deepcopy(self.net)
# 1. run the i-th task and compute loss for k=0
logits = net(x_spt)
loss = F.cross_entropy(logits, y_spt)
grad = torch.autograd.grad(loss, net.parameters())
fast_weights = list(
map(lambda p: p[1] - self.update_lr * p[0], zip(grad, net.parameters()))
)
# this is the loss and accuracy before first update
with torch.no_grad():
# [setsz, nway]
logits_q = net(x_qry, net.parameters(), bn_training=True)
# [setsz]
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
# scalar
correct = torch.eq(pred_q, y_qry).sum().item()
corrects[0] = corrects[0] + correct
# this is the loss and accuracy after the first update
with torch.no_grad():
# [setsz, nway]
logits_q = net(x_qry, fast_weights, bn_training=True)
# [setsz]
pred_q = F.softmax(logits_q, dim=1).argmax(dim=1)
# scalar
correct = torch.eq(pred_q, y_qry).sum().item()
corrects[1] = corrects[1] + correct
del net
accs = torch.tensor(corrects) / querysz
return accs
class ModelOutput(collections.OrderedDict):
"""based on file_utils.py in HuggingFace"""
def __getitem__(self, k):
if isinstance(k, str):
inner_dict = {k: v for (k, v) in self.items()}
return inner_dict[k]
else:
return self.to_tuple()[k]
def __setattr__(self, name, value):
if name in self.keys() and value is not None:
# Don't call self.__setitem__ to avoid recursion errors
super().__setitem__(name, value)
super().__setattr__(name, value)
def __setitem__(self, key, value):
# Will raise a KeyException if needed
super().__setitem__(key, value)
# Don't call self.__setattr__ to avoid recursion errors
super().__setattr__(key, value)
def to_tuple(self):
return tuple(self[k] for k in self.keys())
def create_rand_mask_from_inputs(
from_blocked_mask,
to_blocked_mask,
rand_attn,
num_attention_heads,
num_rand_blocks,
batch_size,
from_seq_length,
from_block_size,
):
"""taken from HF modeling_big_bird.py"""
num_windows = from_seq_length // from_block_size - 2
rand_mask = torch.stack(
[p1[i1.flatten()] for p1, i1 in zip(to_blocked_mask, rand_attn)]
)
rand_mask = rand_mask.view(
batch_size, num_attention_heads, num_windows, num_rand_blocks * from_block_size
)
rand_mask = torch.einsum("blq,bhlk->bhlqk", from_blocked_mask[:, 1:-1], rand_mask)
return rand_mask
class SequentialAppendList(torch.nn.Sequential):
"""from timm/models/vovnet.py"""
def __init__(self, *args):
super(SequentialAppendList, self).__init__(*args)
def forward(self, x: torch.Tensor, concat_list: List[torch.Tensor]) -> torch.Tensor:
for i, module in enumerate(self):
if i == 0:
concat_list.append(module(x))
else:
concat_list.append(module(concat_list[-1]))
x = torch.cat(concat_list, dim=1)
return x, concat_list
class BatchNormAct2d(torch.nn.BatchNorm2d):
"""Taken from timm"""
def __init__(
self,
num_features,
eps=1e-5,
momentum=0.1,
affine=True,
track_running_stats=True,
act_layer=torch.nn.ReLU,
inplace=True,
):
super(BatchNormAct2d, self).__init__(
num_features,
eps=eps,
momentum=momentum,
affine=affine,
track_running_stats=track_running_stats,
)
self.act = act_layer(inplace=inplace)
@torch.jit.ignore
def _forward_python(self, x):
return super().forward(x)
def forward(self, x):
if torch.jit.is_scripting():
x = self._forward_jit(x)
else:
x = self._forward_python(x)
x = self.act(x)
return x
def get_parameter_dtype(parameter):
"""from huggingface model_utils.py"""
try:
return next(parameter.parameters()).dtype
except StopIteration:
# For nn.DataParallel compatibility in PyTorch 1.5
def find_tensor_attributes(module):
tuples = [(k, v) for k, v in module.__dict__.items() if torch.is_tensor(v)]
return tuples
gen = parameter._named_members(get_members_fn=find_tensor_attributes)
first_tuple = next(gen)
return first_tuple[1].dtype
class DummyConfig:
attn_layers = ["local", "lsh", "local", "lsh", "local", "lsh"]
lsh_attn_chunk_length = 64
local_attn_chunk_length = 64
def _get_min_chunk_len(config):
"""from hf_Reformer"""
attn_types = config.attn_layers
attn_types_set = set(attn_types)
if len(attn_types_set) == 1 and attn_types[0] == "lsh":
return config.lsh_attn_chunk_length
elif len(attn_types_set) == 1 and attn_types[0] == "local":
return config.local_attn_chunk_length
elif len(attn_types_set) == 2 and attn_types_set == set(["lsh", "local"]):
return min(config.lsh_attn_chunk_length, config.local_attn_chunk_length)
else:
raise NotImplementedError(
f"Only attn layer types 'lsh' and 'local' exist, but `config.attn_layers`: {config.attn_layers}. Select "
"attn layer types from ['lsh', 'local'] only."
)
def _stable_argsort(vector, dim):
"""from hf_Reformer"""
# this function scales the vector so that torch.argsort is stable.
# torch.argsort is not stable on its own
scale_offset = torch.arange(vector.shape[dim], device=vector.device).view(1, 1, -1)
scale_offset = scale_offset.expand(vector.shape)
scaled_vector = vector.shape[dim] * vector + (scale_offset % vector.shape[dim])
return torch.argsort(scaled_vector, dim=dim)
def _get_sorted_bucket_idx_and_undo_sorted_bucket_idx(buckets):
"""from hf_Reformer"""
# no gradients are needed
with torch.no_grad():
# hash-based sort
sorted_bucket_idx = _stable_argsort(buckets, dim=-1)
# create simple indices to scatter to, to have undo sort
indices = (
torch.arange(sorted_bucket_idx.shape[-1], device=buckets.device)
.view(1, 1, -1)
.expand(sorted_bucket_idx.shape)
)
# get undo sort
undo_sorted_bucket_idx = sorted_bucket_idx.new(*sorted_bucket_idx.size())
undo_sorted_bucket_idx.scatter_(-1, sorted_bucket_idx, indices)
return sorted_bucket_idx, undo_sorted_bucket_idx
class ReproTests(torchdynamo.testing.TestCase):
def test_do_paste_mask(self):
torchdynamo.utils.counters.clear()
with torchdynamo.optimize(torchdynamo.testing.CompileCounter()):
_do_paste_mask(
torch.randn(1, 1, 28, 28),
torch.tensor([[0.0, 1, 2, 4]]) * 1,
427,
640,
True,
)
_do_paste_mask(
torch.randn(1, 1, 28, 28),
torch.tensor([[0.0, 1, 2, 4]]) * 2,
427,
640,
True,
)
_do_paste_mask(
torch.randn(1, 1, 28, 28),
torch.tensor([[0.0, 1, 2, 4]]) * 3,
612,
612,
True,
)
_do_paste_mask(
torch.randn(1, 1, 28, 28),
torch.tensor([[0.0, 1, 2, 4]]) * 4,
612,
612,
True,
)
_do_paste_mask(
torch.randn(1, 1, 28, 28),
torch.tensor([[0.0, 1, 2, 4]]) * 2,
427,
640,
False,
)
self.assertGreaterEqual(torchdynamo.utils.counters["frames"]["ok"], 3)
self.assertEqual(
torchdynamo.utils.counters["frames"]["total"],
torchdynamo.utils.counters["frames"]["ok"],
)
def test_convert_boxes_to_pooler_format(self):
boxes1 = [
Boxes(torch.arange(0, 8).reshape((2, 4))),
Boxes(torch.arange(8, 16).reshape((2, 4))),
]
boxes2 = [
Boxes(torch.arange(16, 20).reshape((1, 4))),
Boxes(torch.arange(20, 24).reshape((1, 4))),
]
correct1 = convert_boxes_to_pooler_format(boxes1)
correct2 = convert_boxes_to_pooler_format(boxes2)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize(cnt):
self.assertTrue(same(convert_boxes_to_pooler_format(boxes1), correct1))
self.assertTrue(same(convert_boxes_to_pooler_format(boxes2), correct2))
self.assertEqual(cnt.frame_count, ifdyn(1, 4))
self.assertEqual(cnt.op_count, 10)
def test_boxes_len(self):
def fn(boxes):
return len(boxes) + boxes.__len__() + boxes.tensor
boxes1 = Boxes(torch.arange(0, 8).reshape((2, 4)))
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(fn(boxes1), boxes1.tensor + 4.0))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, ifdyn(6, 1))
def _reformer(self, nopython):
input = torch.randn([1, 64, 256])
model = ReformerEncoder()
torch.manual_seed(1337)
correct = copy.deepcopy(model)(input)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize(cnt, nopython=nopython):
torch.manual_seed(1337)
self.assertTrue(same(model(input), correct))
return cnt
def test_reformer_eval(self):
with torch.no_grad():
cnt = self._reformer(nopython=True)
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 10)
def test_reformer_train(self):
with torch.enable_grad():
cnt = self._reformer(nopython=False)
# cant inline torch.autograd.Function means graph break
self.assertEqual(cnt.frame_count, 4)
self.assertEqual(cnt.op_count, 10)
def test_longformer_chunk(self):
input1 = torch.randn([1, 4096, 1])
input2 = torch.randn([12, 4096, 64])
correct1 = longformer_chunk(input1)
correct2 = longformer_chunk(input2)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(longformer_chunk(input1), correct1))
self.assertTrue(same(longformer_chunk(input2), correct2))
self.assertTrue(same(longformer_chunk(input1), correct1))
self.assertTrue(same(longformer_chunk(input2), correct2))
self.assertEqual(cnt.frame_count, ifdyn(1, 2))
self.assertEqual(cnt.op_count, ifdyn(19, 4))
def test_hf_t5_forward(self):
input = torch.randn([1, 2048, 512])
model = PartialT5()
correct = model(input)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(model(input), correct))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, ifdyn(14, 11))
@requires_static_shapes
def test_chunk_reformer_ff(self):
input = torch.randn([1, 4096, 256])
model = ChunkReformerFeedForward()
correct = model(input)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(model(input), correct))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 4)
def test_maml(self):
a = torch.randn(5, 1, 28, 28)
b = torch.zeros(5, dtype=torch.int64)
c = torch.randn(75, 1, 28, 28)
d = torch.zeros(75, dtype=torch.int64)
model = PartialMaml()
correct = model(a, b, c, d)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize(cnt):
for _ in range(10):
self.assertTrue(same(model(a, b, c, d), correct))
self.assertEqual(cnt.frame_count, ifdyn(5, 4))
self.assertEqual(cnt.op_count, ifdyn(36, 29))
def test_hf_model_output(self):
ex = ModelOutput(a=torch.randn(10), b=torch.randn(10), c=torch.randn(10))
def fn1(x):
return x["a"] + 1
def fn2(x):
return x.a + 1
def fn3(x):
return x.to_tuple()[0] + 1
def fn4(x):
return x[0] + 1
for fn in (fn1, fn2, fn3, fn4):
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(fn(ex), ex.a + 1))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 1)
@requires_static_shapes
def test_create_rand_mask_from_inputs(self):
args = [
torch.randn([1, 64, 64]),
torch.randn([1, 64, 64]),
torch.zeros([1, 12, 62, 3], dtype=torch.int64),
12,
3,
1,
4096,
64,
]
correct = create_rand_mask_from_inputs(*args)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(create_rand_mask_from_inputs(*args), correct))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 8)
def test_seq_append_list(self):
x = torch.randn(4, 10)
model = SequentialAppendList(
torch.nn.Linear(10, 10),
torch.nn.ReLU(),
torch.nn.Linear(10, 10),
torch.nn.ReLU(),
)
# this one is tricky because it mutates the list provided as an input
l1 = [x]
l2 = [x]
correct, _ = model(x, l1)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
result, l3 = model(x, l2)
self.assertTrue(same(result, correct))
self.assertTrue(same(l1, l2))
self.assertIs(l2, l3)
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 5)
def test_batch_norm_act(self):
a = torch.randn(5, 1, 28, 28)
model = BatchNormAct2d(1).eval()
correct = model(a)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(same(model(a), correct))
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 2)
def test_get_parameter_dtype(self):
model = SequentialAppendList(
torch.nn.Linear(10, 10),
torch.nn.ReLU(),
)
def test_fn(model, x):
return x + torch.randn(10, dtype=get_parameter_dtype(model))
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertEqual(test_fn(model, torch.randn(10)).dtype, torch.float32)
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 2)
def test_reformer_min_chunk_len(self):
def test_fn(cfg):
t = torch.empty(10)
t.fill_(_get_min_chunk_len(cfg))
return t[0]
cfg = DummyConfig()
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertEqual(test_fn(cfg), 64)
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, 3)
def test_reformer_sorting(self):
x = torch.zeros([1, 12, 4096], dtype=torch.int64)
correct = _get_sorted_bucket_idx_and_undo_sorted_bucket_idx(x)
cnt = torchdynamo.testing.CompileCounter()
with torchdynamo.optimize_assert(cnt):
self.assertTrue(
same(_get_sorted_bucket_idx_and_undo_sorted_bucket_idx(x), correct)
)
self.assertEqual(cnt.frame_count, 1)
self.assertEqual(cnt.op_count, ifdyn(28, 14))
| 33.521552 | 117 | 0.607689 |
ace0456cc6f2c413d9ea8ddabf7dbd1b9e356bbe | 8,621 | py | Python | python/dlxapi/models/resource_pool_budget_amount_updated_event.py | dlens/dlxapi | 189a6519240ce625d7a9cdb89e305a335d2aa045 | [
"MIT"
] | null | null | null | python/dlxapi/models/resource_pool_budget_amount_updated_event.py | dlens/dlxapi | 189a6519240ce625d7a9cdb89e305a335d2aa045 | [
"MIT"
] | 1 | 2020-08-20T17:31:43.000Z | 2020-08-20T17:31:43.000Z | python/dlxapi/models/resource_pool_budget_amount_updated_event.py | dlens/dlxapi | 189a6519240ce625d7a9cdb89e305a335d2aa045 | [
"MIT"
] | null | null | null | # coding: utf-8
"""
Decision Lens API
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501
OpenAPI spec version: 1.0
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
from dlxapi.configuration import Configuration
class ResourcePoolBudgetAmountUpdatedEvent(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'portfolio_id': 'str',
'budget_amount': 'float',
'name': 'str',
'time_period': 'TimePeriod',
'id': 'str',
'portfolio_plan': 'PortfolioPlan',
'previous_budget_amount': 'float'
}
attribute_map = {
'portfolio_id': 'portfolioId',
'budget_amount': 'budgetAmount',
'name': 'name',
'time_period': 'timePeriod',
'id': 'id',
'portfolio_plan': 'portfolioPlan',
'previous_budget_amount': 'previousBudgetAmount'
}
def __init__(self, portfolio_id=None, budget_amount=None, name=None, time_period=None, id=None, portfolio_plan=None, previous_budget_amount=None, _configuration=None): # noqa: E501
"""ResourcePoolBudgetAmountUpdatedEvent - a model defined in Swagger""" # noqa: E501
if _configuration is None:
_configuration = Configuration()
self._configuration = _configuration
self._portfolio_id = None
self._budget_amount = None
self._name = None
self._time_period = None
self._id = None
self._portfolio_plan = None
self._previous_budget_amount = None
self.discriminator = None
if portfolio_id is not None:
self.portfolio_id = portfolio_id
if budget_amount is not None:
self.budget_amount = budget_amount
if name is not None:
self.name = name
if time_period is not None:
self.time_period = time_period
if id is not None:
self.id = id
if portfolio_plan is not None:
self.portfolio_plan = portfolio_plan
if previous_budget_amount is not None:
self.previous_budget_amount = previous_budget_amount
@property
def portfolio_id(self):
"""Gets the portfolio_id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The portfolio_id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: str
"""
return self._portfolio_id
@portfolio_id.setter
def portfolio_id(self, portfolio_id):
"""Sets the portfolio_id of this ResourcePoolBudgetAmountUpdatedEvent.
:param portfolio_id: The portfolio_id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: str
"""
self._portfolio_id = portfolio_id
@property
def budget_amount(self):
"""Gets the budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: float
"""
return self._budget_amount
@budget_amount.setter
def budget_amount(self, budget_amount):
"""Sets the budget_amount of this ResourcePoolBudgetAmountUpdatedEvent.
:param budget_amount: The budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: float
"""
self._budget_amount = budget_amount
@property
def name(self):
"""Gets the name of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The name of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: str
"""
return self._name
@name.setter
def name(self, name):
"""Sets the name of this ResourcePoolBudgetAmountUpdatedEvent.
:param name: The name of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: str
"""
self._name = name
@property
def time_period(self):
"""Gets the time_period of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The time_period of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: TimePeriod
"""
return self._time_period
@time_period.setter
def time_period(self, time_period):
"""Sets the time_period of this ResourcePoolBudgetAmountUpdatedEvent.
:param time_period: The time_period of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: TimePeriod
"""
self._time_period = time_period
@property
def id(self):
"""Gets the id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: str
"""
return self._id
@id.setter
def id(self, id):
"""Sets the id of this ResourcePoolBudgetAmountUpdatedEvent.
:param id: The id of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: str
"""
self._id = id
@property
def portfolio_plan(self):
"""Gets the portfolio_plan of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The portfolio_plan of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: PortfolioPlan
"""
return self._portfolio_plan
@portfolio_plan.setter
def portfolio_plan(self, portfolio_plan):
"""Sets the portfolio_plan of this ResourcePoolBudgetAmountUpdatedEvent.
:param portfolio_plan: The portfolio_plan of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: PortfolioPlan
"""
self._portfolio_plan = portfolio_plan
@property
def previous_budget_amount(self):
"""Gets the previous_budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:return: The previous_budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:rtype: float
"""
return self._previous_budget_amount
@previous_budget_amount.setter
def previous_budget_amount(self, previous_budget_amount):
"""Sets the previous_budget_amount of this ResourcePoolBudgetAmountUpdatedEvent.
:param previous_budget_amount: The previous_budget_amount of this ResourcePoolBudgetAmountUpdatedEvent. # noqa: E501
:type: float
"""
self._previous_budget_amount = previous_budget_amount
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ResourcePoolBudgetAmountUpdatedEvent, dict):
for key, value in self.items():
result[key] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, ResourcePoolBudgetAmountUpdatedEvent):
return False
return self.to_dict() == other.to_dict()
def __ne__(self, other):
"""Returns true if both objects are not equal"""
if not isinstance(other, ResourcePoolBudgetAmountUpdatedEvent):
return True
return self.to_dict() != other.to_dict()
| 30.789286 | 185 | 0.634845 |
ace04625d5d81c8e72bf2e2cd361e17e830cfb8e | 328 | py | Python | submissions/best-sightseeing-pair/solution.py | Wattyyy/LeetCode | 13a9be056d0a0c38c2f8c8222b11dc02cb25a935 | [
"MIT"
] | null | null | null | submissions/best-sightseeing-pair/solution.py | Wattyyy/LeetCode | 13a9be056d0a0c38c2f8c8222b11dc02cb25a935 | [
"MIT"
] | 1 | 2022-03-04T20:24:32.000Z | 2022-03-04T20:31:58.000Z | submissions/best-sightseeing-pair/solution.py | Wattyyy/LeetCode | 13a9be056d0a0c38c2f8c8222b11dc02cb25a935 | [
"MIT"
] | null | null | null | class Solution:
def maxScoreSightseeingPair(self, values: List[int]) -> int:
max_val = values[0] - 1
ans = 0
for i, val in enumerate(values):
if i == 0:
continue
ans = max(max_val + val, ans)
max_val = max(max_val - 1, val - 1)
return ans
| 27.333333 | 64 | 0.5 |
ace0469f85eb51c92cfc9d6b19d1e0511c53414b | 1,884 | py | Python | local_libs/astrologist.py | jcq15/frogWechaty | a8abb41d9dfe5e7d6d8100fe5aec0881bc715430 | [
"MIT"
] | null | null | null | local_libs/astrologist.py | jcq15/frogWechaty | a8abb41d9dfe5e7d6d8100fe5aec0881bc715430 | [
"MIT"
] | null | null | null | local_libs/astrologist.py | jcq15/frogWechaty | a8abb41d9dfe5e7d6d8100fe5aec0881bc715430 | [
"MIT"
] | null | null | null | import requests
from bs4 import BeautifulSoup
class Astrologist:
def __init__(self):
self.xz_cn_to_eng = {
'狮子座': 'leo',
'金牛座': 'taurus',
'白羊座': 'aries',
'双子座': 'gemini',
'巨蟹座': 'cancer',
'处女座': 'virgo',
'天秤座': 'libra',
'天蝎座': 'scorpio',
'射手座': 'sagittarius',
'摩羯座': 'capricorn',
'水瓶座': 'aquarius',
'双鱼座': 'pisces'}
self.source_url = 'https://www.xzw.com/fortune/'
def get_data(self, xz):
if xz not in self.xz_cn_to_eng:
return '这是什么星座啊，我不认识！'
else:
xz_en = self.xz_cn_to_eng[xz]
url = self.source_url + xz_en + '/'
ri = requests.get(url=url) # 访问页面
# ri.encoding = ri.apparent_encoding # encoding
soupi = BeautifulSoup(ri.text, 'lxml') # 解析页面
infor1 = soupi.find('div', class_="c_main").find('ul').find_all('li')
infor2 = soupi.find('div', class_="c_cont").find_all('p')
res = '你是可爱的' + xz + '宝宝！\n'
for i in range(4):
star_c = int(infor1[i].find('em')['style'].split(':')[1].split('p')[0]) // 16
str_tmp = '【' + infor1[i].text[:-1] + '】' + star_c * '★' + (5 - star_c) * '☆' + '\n'
str_txt = infor2[i].find('span').text + '\n'
res = res + str_tmp + str_txt
for i in range(4, 10):
print(infor1[i])
print(infor1[i].find('label').text)
print(infor1[i].text.split('：'))
str_tmp = '【' + infor1[i].find('label').text[:-1] + '】' + infor1[i].text.split('：')[-1] + '\n'
if i == 4:
str_tmp = str_tmp + infor2[i].find('span').text + '\n'
res = res + str_tmp
return res
| 34.888889 | 111 | 0.448514 |
ace047399e75a7ea2511f995718cf9a6f2ba87f1 | 139 | py | Python | django_passwords/apps.py | aiakos/aiakos | a591e7ef13ab9e8e14b4d3569d43fce694c4150a | [
"BSD-2-Clause",
"MIT"
] | 4 | 2017-04-28T19:09:17.000Z | 2018-07-03T04:43:54.000Z | django_passwords/apps.py | aiakos/aiakos | a591e7ef13ab9e8e14b4d3569d43fce694c4150a | [
"BSD-2-Clause",
"MIT"
] | 2 | 2020-06-05T17:46:47.000Z | 2021-06-10T17:22:58.000Z | django_passwords/apps.py | aiakos/aiakos | a591e7ef13ab9e8e14b4d3569d43fce694c4150a | [
"BSD-2-Clause",
"MIT"
] | 2 | 2017-08-14T07:15:14.000Z | 2019-03-04T14:02:05.000Z | from django.apps import AppConfig
class PasswordsConfig(AppConfig):
name = 'django_passwords'
verbose_name = 'Password authentication'
| 19.857143 | 41 | 0.805755 |
ace0478e23bbccbb714ed9525c69b4d160a53084 | 2,851 | py | Python | tests/test_feedback_file.py | JasonCaldwellMBA/Winning_Texas_Holdem_Strategy | 6ece8756f45982eee99b13e174caed515a7a31d8 | [
"MIT"
] | 1 | 2020-06-12T08:25:42.000Z | 2020-06-12T08:25:42.000Z | tests/test_feedback_file.py | AutomatingSoftwareTesting/Winning_Texas_Holdem_Strategy | 6ece8756f45982eee99b13e174caed515a7a31d8 | [
"MIT"
] | null | null | null | tests/test_feedback_file.py | AutomatingSoftwareTesting/Winning_Texas_Holdem_Strategy | 6ece8756f45982eee99b13e174caed515a7a31d8 | [
"MIT"
] | 1 | 2019-09-04T14:54:45.000Z | 2019-09-04T14:54:45.000Z | from app.feedback_file import FeedbackFile
class TestFeedbackFile:
def test_file_name(self):
"""The directory paths will be unique for each installation."""
import datetime
date_time = datetime.datetime.now().strftime("%m-%d-%y %H%M")
setup_specific_path = "C:\\Users\\jdcald13\\Documents\\repos\\Winning_Texas_Holdem_Strategy\\"
file_name_1 = str(FeedbackFile(8))
assert file_name_1 == setup_specific_path + "../reports/8-Handed Range Trainer " + str(date_time) + ".csv" # .csv is the default file extension.
file_name_2 = str(FeedbackFile(5, "txt"))
assert file_name_2 == setup_specific_path + "../reports/5-Handed Range Trainer " + str(date_time) + ".txt"
def test_create_file(self, tmpdir):
"""Using temporary directories so that nothing is created from a user's perspective if this was also used in a live environment."""
temp_file = tmpdir.mkdir("create").join("temp_file.csv")
temp_file.write("Hand Number,Date/Time,Range File,Feedback,Position,Position Percentage,Min Opening Hand Type,Hole Cards,Hand Type,Hand Ranking Percentage,Your Decision,Correct Decision,Score\n")
assert temp_file.read() == "Hand Number,Date/Time,Range File,Feedback,Position,Position Percentage,Min Opening Hand Type,Hole Cards,Hand Type,Hand Ranking Percentage,Your Decision,Correct Decision,Score\n"
assert len(tmpdir.listdir()) == 1
def test_save_hand(self, tmpdir):
hand_num, date_time, session_range, feedback, position, min_play, min_open_hand, hole_cards, type_hand, hand_percent, decision, correct_decision, score = \
1, "5/5/2017 3:54:50", "test.txt", "Correct", "Button", .333333, "K2o", "Kc 7c", "K7c", .267019, "open", "open", 1
temp_file = tmpdir.mkdir("save").join("temp_file.txt")
temp_file.write("%i,%s,%s,%s,%s,%0.2f,%s,%s,%s,%0.2f,%s,%s,%i\n" % (hand_num, date_time, session_range, feedback, position, min_play * 100, min_open_hand, hole_cards, type_hand, hand_percent * 100,
decision, correct_decision, score))
assert temp_file.read() == "1,5/5/2017 3:54:50,test.txt,Correct,Button,33.33,K2o,Kc 7c,K7c,26.70,open,open,1\n"
assert len(tmpdir.listdir()) == 1
temp_file_2 = tmpdir.join("temp_file_2.csv")
temp_file_2.write("%i,%s,%s,%s,%s,%0.2f,%s,%s,%s,%0.2f,%s,%s,%i\n" % (hand_num, date_time, session_range, feedback, position, min_play * 100, min_open_hand, hole_cards, type_hand, hand_percent * 100,
decision, correct_decision, score))
assert temp_file_2.read() == "1,5/5/2017 3:54:50,test.txt,Correct,Button,33.33,K2o,Kc 7c,K7c,26.70,open,open,1\n"
assert len(tmpdir.listdir()) == 2
| 75.026316 | 213 | 0.651701 |
ace0479fc11ab626aa8d6caef73875fad2b19086 | 8,227 | py | Python | wwdtm/host/host.py | questionlp/wwdtm | f3cf3399c22bf19e369e6e0250e7c72de0be3a90 | [
"Apache-2.0"
] | null | null | null | wwdtm/host/host.py | questionlp/wwdtm | f3cf3399c22bf19e369e6e0250e7c72de0be3a90 | [
"Apache-2.0"
] | 1 | 2022-01-17T04:25:49.000Z | 2022-01-17T04:25:49.000Z | wwdtm/host/host.py | questionlp/wwdtm | f3cf3399c22bf19e369e6e0250e7c72de0be3a90 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
# vim: set noai syntax=python ts=4 sw=4:
#
# Copyright (c) 2018-2021 Linh Pham
# wwdtm is released under the terms of the Apache License 2.0
"""Wait Wait Don't Tell Me! Stats Host Data Retrieval Functions
"""
from functools import lru_cache
from typing import Any, Dict, List, Optional
from mysql.connector import connect
from slugify import slugify
from wwdtm.host.appearances import HostAppearances
from wwdtm.host.utility import HostUtility
from wwdtm.validation import valid_int_id
class Host:
"""This class contains functions used to retrieve host data from a
copy of the Wait Wait Stats database.
:param connect_dict: Dictionary containing database connection
settings as required by mysql.connector.connect
:param database_connection: mysql.connector.connect database
connection
"""
def __init__(self,
connect_dict: Optional[Dict[str, Any]] = None,
database_connection: Optional[connect] = None):
"""Class initialization method.
"""
if connect_dict:
self.connect_dict = connect_dict
self.database_connection = connect(**connect_dict)
elif database_connection:
if not database_connection.is_connected():
database_connection.reconnect()
self.database_connection = database_connection
self.appearances = HostAppearances(database_connection=self.database_connection)
self.utility = HostUtility(database_connection=self.database_connection)
def retrieve_all(self) -> List[Dict[str, Any]]:
"""Returns a list of dictionary objects containing host ID,
name and slug string for all hosts.
:return: List of all hosts and their corresponding information.
If hosts could not be retrieved, an empty list is returned.
"""
cursor = self.database_connection.cursor(named_tuple=True)
query = ("SELECT hostid AS id, host AS name, hostslug AS slug, "
"hostgender AS gender "
"FROM ww_hosts "
"ORDER BY host ASC;")
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
if not results:
return []
hosts = []
for row in results:
hosts.append({
"id": row.id,
"name": row.name,
"gender": row.gender,
"slug": row.slug if row.slug else slugify(row.name),
})
return hosts
def retrieve_all_details(self) -> List[Dict[str, Any]]:
"""Returns a list of dictionary objects containing host ID,
name, slug string and appearance information for all hosts.
:return: List of all hosts and their corresponding information
and appearances. If hosts could not be retrieved, an empty
list is returned.
"""
cursor = self.database_connection.cursor(named_tuple=True)
query = ("SELECT hostid AS id, host AS name, hostslug AS slug, "
"hostgender AS gender "
"FROM ww_hosts "
"ORDER BY host ASC;")
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
if not results:
return []
hosts = []
for row in results:
hosts.append({
"id": row.id,
"name": row.name,
"gender": row.gender,
"slug": row.slug if row.slug else slugify(row.name),
"appearances": self.appearances.retrieve_appearances_by_id(row.id),
})
return hosts
def retrieve_all_ids(self) -> List[int]:
"""Returns a list of all host IDs from the database, sorted by
host name.
:return: List of all host IDs. If host IDs could not be
retrieved, an empty list is returned.
"""
cursor = self.database_connection.cursor(dictionary=False)
query = ("SELECT hostid FROM ww_hosts "
"ORDER BY host ASC;")
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
if not results:
return []
return [v[0] for v in results]
def retrieve_all_slugs(self) -> List[str]:
"""Returns a list of all host slug strings from the database,
sorted by host name.
:return: List of all host slug strings. If host slug strings
could not be retrieved, an empty list is returned.
"""
cursor = self.database_connection.cursor(dictionary=False)
query = ("SELECT hostslug FROM ww_hosts "
"ORDER BY host ASC;")
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
if not results:
return []
return [v[0] for v in results]
@lru_cache(typed=True)
def retrieve_by_id(self, host_id: int) -> Dict[str, Any]:
"""Returns a dictionary object containing host ID, name and
slug string for the requested host ID.
:param host_id: Host ID
:return: Dictionary containing host information. If host
information could not be retrieved, an empty dictionary is
returned.
"""
if not valid_int_id(host_id):
return {}
cursor = self.database_connection.cursor(named_tuple=True)
query = ("SELECT hostid AS id, host AS name, hostslug AS slug, "
"hostgender AS gender "
"FROM ww_hosts "
"WHERE hostid = %s "
"LIMIT 1;")
cursor.execute(query, (host_id, ))
result = cursor.fetchone()
cursor.close()
if not result:
return {}
return {
"id": result.id,
"name": result.name,
"gender": result.gender,
"slug": result.slug if result.slug else slugify(result.name),
}
@lru_cache(typed=True)
def retrieve_by_slug(self, host_slug: str) -> Dict[str, Any]:
"""Returns a dictionary object containing host ID, name and
slug string for the requested host slug string.
:param host_slug: Host slug string
:return: Dictionary containing host information. If host
information could be retrieved, an empty dictionary is
returned.
"""
try:
slug = host_slug.strip()
if not slug:
return {}
except AttributeError:
return {}
id_ = self.utility.convert_slug_to_id(slug)
if not id_:
return {}
return self.retrieve_by_id(id_)
@lru_cache(typed=True)
def retrieve_details_by_id(self, host_id: int) -> Dict[str, Any]:
"""Returns a dictionary object containing host ID, name, slug
string and appearance information for the requested host ID.
:param host_id: Host ID
:return: Dictionary containing host information and their
appearances. If host information could be retrieved, an
empty dictionary is returned.
"""
if not valid_int_id(host_id):
return {}
info = self.retrieve_by_id(host_id)
if not info:
return {}
info["appearances"] = self.appearances.retrieve_appearances_by_id(host_id)
return info
@lru_cache(typed=True)
def retrieve_details_by_slug(self, host_slug: str) -> Dict[str, Any]:
"""Returns a dictionary object containing host ID, name, slug
string and appearance information for the requested host slug
string.
:param host_slug: Host slug string
:return: Dictionary containing host information and their
appearances. If host information could be retrieved, an
empty dictionary is returned.
"""
try:
slug = host_slug.strip()
if not slug:
return {}
except AttributeError:
return {}
id_ = self.utility.convert_slug_to_id(slug)
if not id_:
return {}
return self.retrieve_details_by_id(id_)
| 33.579592 | 88 | 0.596694 |
ace047ab35182a6aa7bbd4555d9a28759230c94b | 1,666 | py | Python | restaurant/migrations/0005_order.py | mohammedaliyu136/pazar-python-backend-v2 | d794db72e373080f2373ba757c4d16589779f331 | [
"MIT"
] | null | null | null | restaurant/migrations/0005_order.py | mohammedaliyu136/pazar-python-backend-v2 | d794db72e373080f2373ba757c4d16589779f331 | [
"MIT"
] | null | null | null | restaurant/migrations/0005_order.py | mohammedaliyu136/pazar-python-backend-v2 | d794db72e373080f2373ba757c4d16589779f331 | [
"MIT"
] | null | null | null | # Generated by Django 2.1.3 on 2021-08-24 15:57
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('restaurant', '0004_auto_20210820_2239'),
]
operations = [
migrations.CreateModel(
name='Order',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('coupon_discount_amount', models.FloatField()),
('coupon_discount_title', models.CharField(max_length=100)),
('order_amount', models.FloatField()),
('order_type', models.CharField(max_length=20)),
('payment_method', models.CharField(max_length=11)),
('contact_person_name', models.CharField(max_length=100)),
('contact_person_phone', models.CharField(max_length=100)),
('delivery_address', models.CharField(max_length=100)),
('order_note', models.CharField(max_length=200)),
('coupon_code', models.CharField(max_length=11)),
('restaurant_fk', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='restaurant.Restaurant')),
('user_fk', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
),
]
| 45.027027 | 126 | 0.627851 |
ace048809efe240df247cf013bc55d6c29b7f2a0 | 1,475 | py | Python | iot/api-client/gcs_file_to_device/gcs_example_mqtt_device_test.py | summersab/python-docs-samples | 7c1e9685fe190f7789d8e1dbcfe8c01a20e3dc66 | [
"Apache-2.0"
] | 4 | 2018-12-23T18:17:14.000Z | 2020-01-05T19:13:58.000Z | iot/api-client/gcs_file_to_device/gcs_example_mqtt_device_test.py | summersab/python-docs-samples | 7c1e9685fe190f7789d8e1dbcfe8c01a20e3dc66 | [
"Apache-2.0"
] | 320 | 2020-11-08T21:02:43.000Z | 2022-02-10T10:43:29.000Z | iot/api-client/gcs_file_to_device/gcs_example_mqtt_device_test.py | summersab/python-docs-samples | 7c1e9685fe190f7789d8e1dbcfe8c01a20e3dc66 | [
"Apache-2.0"
] | 4 | 2018-06-03T14:43:25.000Z | 2019-11-24T04:05:18.000Z | # Copyright 2017 Google, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from google.cloud import storage
import pytest
import gcs_example_mqtt_device as device
gcs_bucket = os.environ['CLOUD_STORAGE_BUCKET']
cloud_region = 'us-central1'
destination_file_name = 'destination-file.bin'
project_id = os.environ['GCLOUD_PROJECT']
@pytest.fixture(scope='module')
def test_blob():
"""Provides a pre-existing blob in the test bucket."""
bucket = storage.Client().bucket(gcs_bucket)
# Name of the blob
blob = bucket.blob('iot_core_store_file_gcs')
# Text in the blob
blob.upload_from_string('This file on GCS will go to a device.')
yield blob
# Clean up
blob.delete()
def test_download_blob(test_blob, capsys):
device.download_blob(gcs_bucket, test_blob.name, destination_file_name)
out, _ = capsys.readouterr()
assert 'Config {} downloaded to {}.'.format(
test_blob.name, destination_file_name) in out
| 30.102041 | 75 | 0.741017 |
ace048eb354c3aa7f3325a140b2c4eb0faf38b9e | 6,918 | py | Python | sydent/sydent.py | VladimirCourse/sydent-twilio | 345911a81b9f38e709fd2343e4291af1f65f7ebb | [
"Apache-2.0"
] | null | null | null | sydent/sydent.py | VladimirCourse/sydent-twilio | 345911a81b9f38e709fd2343e4291af1f65f7ebb | [
"Apache-2.0"
] | 1 | 2020-07-21T14:37:16.000Z | 2020-07-21T14:37:16.000Z | sydent/sydent.py | VladimirCourse/sydent-twilio | 345911a81b9f38e709fd2343e4291af1f65f7ebb | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
# Copyright 2014 OpenMarket Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ConfigParser
import logging
import os
import twisted.internet.reactor
from twisted.python import log
from db.sqlitedb import SqliteDatabase
from http.httpcommon import SslComponents
from http.httpserver import ClientApiHttpServer, ReplicationHttpsServer
from http.httpsclient import ReplicationHttpsClient
from http.servlets.blindlysignstuffservlet import BlindlySignStuffServlet
from http.servlets.pubkeyservlets import EphemeralPubkeyIsValidServlet, PubkeyIsValidServlet
from validators.emailvalidator import EmailValidator
from validators.msisdnvalidator import MsisdnValidator
from sign.ed25519 import SydentEd25519
from http.servlets.emailservlet import EmailRequestCodeServlet, EmailValidateCodeServlet
from http.servlets.msisdnservlet import MsisdnRequestCodeServlet, MsisdnValidateCodeServlet
from http.servlets.lookupservlet import LookupServlet
from http.servlets.bulklookupservlet import BulkLookupServlet
from http.servlets.pubkeyservlets import Ed25519Servlet
from http.servlets.threepidbindservlet import ThreePidBindServlet
from http.servlets.replication import ReplicationPushServlet
from http.servlets.getvalidated3pidservlet import GetValidated3pidServlet
from http.servlets.store_invite_servlet import StoreInviteServlet
from threepid.bind import ThreepidBinder
from replication.pusher import Pusher
logger = logging.getLogger(__name__)
class Sydent:
CONFIG_SECTIONS = ['general', 'db', 'http', 'email', 'crypto', 'sms']
CONFIG_DEFAULTS = {
# general
'server.name': '',
'log.path': '',
'pidfile.path': 'sydent.pid',
# db
'db.file': 'sydent.db',
# http
'clientapi.http.port': '8090',
'replication.https.certfile': '',
'replication.https.cacert': '', # This should only be used for testing
'replication.https.port': '4434',
'obey_x_forwarded_for': False,
# email
'email.template': 'res/email.template',
'email.from': 'Sydent Validation <noreply@{hostname}>',
'email.subject': 'Your Validation Token',
'email.invite.subject': '%(sender_display_name)s has invited you to chat',
'email.smtphost': 'localhost',
'email.smtpport': '25',
'email.smtpusername': '',
'email.smtppassword': '',
'email.hostname': '',
'email.tlsmode': '0',
# sms
'bodyTemplate': 'Your code is {token}',
# crypto
'ed25519.signingkey': '',
}
def __init__(self):
logger.info("Starting Sydent server")
self.parse_config()
logPath = self.cfg.get('general', "log.path")
if logPath != '':
logging.basicConfig(level=logging.INFO, filename=logPath)
else:
logging.basicConfig(level=logging.INFO, filename=logPath)
self.pidfile = self.cfg.get('general', "pidfile.path");
observer = log.PythonLoggingObserver()
observer.start()
self.db = SqliteDatabase(self).db
self.server_name = self.cfg.get('general', 'server.name')
if self.server_name == '':
self.server_name = os.uname()[1]
logger.warn(("You had not specified a server name. I have guessed that this server is called '%s' "
+ " and saved this in the config file. If this is incorrect, you should edit server.name in "
+ "the config file.") % (self.server_name,))
self.cfg.set('general', 'server.name', self.server_name)
self.save_config()
self.validators = Validators()
self.validators.email = EmailValidator(self)
self.validators.msisdn = MsisdnValidator(self)
self.keyring = Keyring()
self.keyring.ed25519 = SydentEd25519(self).signing_key
self.keyring.ed25519.alg = 'ed25519'
self.servlets = Servlets()
self.servlets.emailRequestCode = EmailRequestCodeServlet(self)
self.servlets.emailValidate = EmailValidateCodeServlet(self)
self.servlets.msisdnRequestCode = MsisdnRequestCodeServlet(self)
self.servlets.msisdnValidate = MsisdnValidateCodeServlet(self)
self.servlets.lookup = LookupServlet(self)
self.servlets.bulk_lookup = BulkLookupServlet(self)
self.servlets.pubkey_ed25519 = Ed25519Servlet(self)
self.servlets.pubkeyIsValid = PubkeyIsValidServlet(self)
self.servlets.ephemeralPubkeyIsValid = EphemeralPubkeyIsValidServlet(self)
self.servlets.threepidBind = ThreePidBindServlet(self)
self.servlets.replicationPush = ReplicationPushServlet(self)
self.servlets.getValidated3pid = GetValidated3pidServlet(self)
self.servlets.storeInviteServlet = StoreInviteServlet(self)
self.servlets.blindlySignStuffServlet = BlindlySignStuffServlet(self)
self.threepidBinder = ThreepidBinder(self)
self.sslComponents = SslComponents(self)
self.clientApiHttpServer = ClientApiHttpServer(self)
self.replicationHttpsServer = ReplicationHttpsServer(self)
self.replicationHttpsClient = ReplicationHttpsClient(self)
self.pusher = Pusher(self)
def parse_config(self):
self.cfg = ConfigParser.SafeConfigParser(Sydent.CONFIG_DEFAULTS)
for sect in Sydent.CONFIG_SECTIONS:
try:
self.cfg.add_section(sect)
except ConfigParser.DuplicateSectionError:
pass
self.cfg.read("sydent.conf")
def save_config(self):
fp = open("sydent.conf", 'w')
self.cfg.write(fp)
fp.close()
def run(self):
self.clientApiHttpServer.setup()
self.replicationHttpsServer.setup()
self.pusher.setup()
if self.pidfile:
with open(self.pidfile, 'w') as pidfile:
pidfile.write(str(os.getpid()) + "\n")
twisted.internet.reactor.run()
def ip_from_request(self, request):
if (self.cfg.get('http', 'obey_x_forwarded_for') and
request.requestHeaders.hasHeader("X-Forwarded-For")):
return request.requestHeaders.getRawHeaders("X-Forwarded-For")[0]
return request.getClientIP()
class Validators:
pass
class Servlets:
pass
class Keyring:
pass
if __name__ == '__main__':
syd = Sydent()
syd.run()
| 36.03125 | 117 | 0.688927 |
ace04919e7c9990f16060f26a87767906d240e1b | 10,095 | py | Python | Blik2D/addon/tensorflow-1.2.1_for_blik/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py | BonexGu/Blik2D | 8e0592787e5c8e8a28682d0e1826b8223eae5983 | [
"MIT"
] | 13 | 2017-02-22T02:20:06.000Z | 2018-06-06T04:18:03.000Z | Blik2D/addon/tensorflow-1.2.1_for_blik/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py | BonexGu/Blik2D | 8e0592787e5c8e8a28682d0e1826b8223eae5983 | [
"MIT"
] | null | null | null | Blik2D/addon/tensorflow-1.2.1_for_blik/tensorflow/contrib/data/python/kernel_tests/iterator_ops_test.py | BonexGu/Blik2D | 8e0592787e5c8e8a28682d0e1826b8223eae5983 | [
"MIT"
] | 3 | 2017-06-09T10:39:33.000Z | 2021-04-08T16:13:30.000Z | # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for the experimental input pipeline ops."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.contrib.data.python.ops import dataset_ops
from tensorflow.python.client import session
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.ops import math_ops
from tensorflow.python.platform import test
from tensorflow.python.training import server_lib
class IteratorTest(test.TestCase):
def testOneShotIterator(self):
components = [np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7)]
def _map_fn(x, y, z):
return math_ops.square(x), math_ops.square(y), math_ops.square(z)
iterator = (dataset_ops.Dataset.from_tensor_slices(components).map(_map_fn)
.repeat(14).make_one_shot_iterator())
get_next = iterator.get_next()
self.assertEqual([c.shape[1:] for c in components],
[t.shape for t in get_next])
with self.test_session() as sess:
for _ in range(14):
for i in range(7):
result = sess.run(get_next)
for component, result_component in zip(components, result):
self.assertAllEqual(component[i]**2, result_component)
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
def testOneShotIteratorCaptureByValue(self):
components = [np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7)]
tensor_components = [ops.convert_to_tensor(c) for c in components]
def _map_fn(x, y, z):
return math_ops.square(x), math_ops.square(y), math_ops.square(z)
iterator = (dataset_ops.Dataset.from_tensor_slices(tensor_components)
.map(_map_fn).repeat(14).make_one_shot_iterator())
get_next = iterator.get_next()
self.assertEqual([c.shape[1:] for c in components],
[t.shape for t in get_next])
with self.test_session() as sess:
for _ in range(14):
for i in range(7):
result = sess.run(get_next)
for component, result_component in zip(components, result):
self.assertAllEqual(component[i]**2, result_component)
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
def testOneShotIteratorInsideContainer(self):
components = [np.arange(7),
np.array([[1, 2, 3]]) * np.arange(7)[:, np.newaxis],
np.array(37.0) * np.arange(7)]
def within_container():
def _map_fn(x, y, z):
return math_ops.square(x), math_ops.square(y), math_ops.square(z)
iterator = (dataset_ops.Dataset.from_tensor_slices(components)
.map(_map_fn).repeat(14).make_one_shot_iterator())
return iterator.get_next()
server = server_lib.Server.create_local_server()
# Create two iterators within unique containers, and run them to
# make sure that the resources aren't shared.
#
# The test below would fail if cname were the same across both
# sessions.
for i in range(2):
with session.Session(server.target) as sess:
cname = "iteration%d" % i
with ops.container(cname):
get_next = within_container()
for _ in range(14):
for i in range(7):
result = sess.run(get_next)
for component, result_component in zip(components, result):
self.assertAllEqual(component[i]**2, result_component)
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
def testSimpleSharedResource(self):
components = [
np.array(1, dtype=np.int64),
np.array([1, 2, 3], dtype=np.int64),
np.array(37.0, dtype=np.float64)
]
server = server_lib.Server.create_local_server()
# Create two non-overlapping sessions that share the same iterator
# resource on the same server, and verify that an action of the
# first session (initializing the iterator) is visible in the
# second session.
with ops.Graph().as_default():
iterator = (dataset_ops.Dataset.from_tensors(components)
.map(lambda x, y, z: (x, y, z)).make_initializable_iterator(
shared_name="shared_iterator"))
init_op = iterator.initializer
get_next = iterator.get_next()
with session.Session(server.target) as sess:
sess.run(init_op)
results = sess.run(get_next)
for component, result_component in zip(components, results):
self.assertAllEqual(component, result_component)
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
# Re-initialize the iterator in the first session.
sess.run(init_op)
with ops.Graph().as_default():
# Re-define the iterator manually, without defining any of the
# functions in this graph, to ensure that we are not
# accidentally redefining functions with the same names in the
# new graph.
iterator = dataset_ops.Iterator.from_structure(
shared_name="shared_iterator",
output_types=[dtypes.int64, dtypes.int64, dtypes.float64],
output_shapes=[[], [3], []])
get_next = iterator.get_next()
with session.Session(server.target) as sess:
# Use the iterator without re-initializing in the second session.
results = sess.run(get_next)
for component, result_component in zip(components, results):
self.assertAllEqual(component, result_component)
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
def testNotInitializedError(self):
components = [np.array(1), np.array([1, 2, 3]), np.array(37.0)]
iterator = (dataset_ops.Dataset.from_tensors(components)
.make_initializable_iterator())
get_next = iterator.get_next()
with self.test_session() as sess:
with self.assertRaisesRegexp(errors.FailedPreconditionError,
"iterator has not been initialized"):
sess.run(get_next)
def testReinitializableIterator(self):
dataset_3 = dataset_ops.Dataset.from_tensors(
constant_op.constant([1, 2, 3]))
dataset_4 = dataset_ops.Dataset.from_tensors(
constant_op.constant([4, 5, 6, 7]))
iterator = dataset_ops.Iterator.from_structure(dataset_3.output_types,
[None])
dataset_3_init_op = iterator.make_initializer(dataset_3)
dataset_4_init_op = iterator.make_initializer(dataset_4)
get_next = iterator.get_next()
self.assertEqual(dataset_3.output_types, iterator.output_types)
self.assertEqual(dataset_4.output_types, iterator.output_types)
self.assertEqual([None], iterator.output_shapes.as_list())
with self.test_session() as sess:
# The iterator is initially uninitialized.
with self.assertRaises(errors.FailedPreconditionError):
sess.run(get_next)
# Initialize with one dataset.
sess.run(dataset_3_init_op)
self.assertAllEqual([1, 2, 3], sess.run(get_next))
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
# Initialize with a different dataset.
sess.run(dataset_4_init_op)
self.assertAllEqual([4, 5, 6, 7], sess.run(get_next))
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
# Reinitialize with the first dataset.
sess.run(dataset_3_init_op)
self.assertAllEqual([1, 2, 3], sess.run(get_next))
with self.assertRaises(errors.OutOfRangeError):
sess.run(get_next)
def testReinitializableIteratorStaticErrors(self):
# Non-matching structure for types and shapes.
with self.assertRaises(TypeError):
iterator = dataset_ops.Iterator.from_structure((dtypes.int64,
dtypes.float64), [None])
# Test validation of dataset argument.
iterator = dataset_ops.Iterator.from_structure((dtypes.int64,
dtypes.float64))
# Incompatible structure.
with self.assertRaises(ValueError):
iterator.make_initializer(
dataset_ops.Dataset.from_tensors(((constant_op.constant(
[1, 2, 3], dtype=dtypes.int64),), (constant_op.constant(
[4., 5., 6., 7.], dtype=dtypes.float64),))))
# Incompatible types.
with self.assertRaises(TypeError):
iterator.make_initializer(
dataset_ops.Dataset.from_tensors((constant_op.constant(
[1, 2, 3], dtype=dtypes.int32), constant_op.constant(
[4., 5., 6., 7.], dtype=dtypes.float32))))
# Incompatible shapes.
iterator = dataset_ops.Iterator.from_structure(
(dtypes.int64, dtypes.float64), ([None], []))
with self.assertRaises(TypeError):
iterator.make_initializer(
dataset_ops.Dataset.from_tensors((constant_op.constant(
[1, 2, 3], dtype=dtypes.int64), constant_op.constant(
[4., 5., 6., 7.], dtype=dtypes.float64))))
if __name__ == "__main__":
test.main()
| 39.901186 | 80 | 0.657157 |
ace04a99394b9da4bf20fa6bdf613f538a785137 | 14,099 | py | Python | spambayes/ImageStripper.py | mpwillson/spambayes3 | b51d7bb9016066234ce88dad65faabed85f63d78 | [
"PSF-2.0"
] | 1 | 2020-03-21T15:17:22.000Z | 2020-03-21T15:17:22.000Z | spambayes/ImageStripper.py | mpwillson/spambayes3 | b51d7bb9016066234ce88dad65faabed85f63d78 | [
"PSF-2.0"
] | 1 | 2022-02-22T22:23:55.000Z | 2022-02-22T22:23:55.000Z | spambayes/ImageStripper.py | mpwillson/spambayes3 | b51d7bb9016066234ce88dad65faabed85f63d78 | [
"PSF-2.0"
] | null | null | null | """
This is the place where we try and discover information buried in images.
"""
import sys
import os
import tempfile
import math
import atexit
try:
import io as StringIO
except ImportError:
import io
try:
from PIL import Image, ImageSequence
except ImportError:
Image = None
from spambayes.safepickle import pickle_read, pickle_write
from spambayes.port import md5
# The email mime object carrying the image data can have a special attribute
# which indicates that a message had an image, but it was large (ie, larger
# than the 'max_image_size' option.) This allows the provider of the email
# object to avoid loading huge images into memory just to have this image
# stripper ignore it.
# If the attribute exists, it should be the size of the image (we assert it
# is > max_image_size). The image payload is ignored.
# A 'cleaner' option would be to look at a header - but an attribute was
# chosen to avoid spammers getting wise and 'injecting' the header into the
# message body of a mime section.
image_large_size_attribute = "spambayes_image_large_size"
from spambayes.Options import options
# copied from tokenizer.py - maybe we should split it into pieces...
def log2(n, log=math.log, c=math.log(2)):
return log(n)/c
def is_executable(prog):
if sys.platform == "win32":
return True
info = os.stat(prog)
return (info.st_uid == os.getuid() and (info.st_mode & 0o100) or
info.st_gid == os.getgid() and (info.st_mode & 0o010) or
info.st_mode & 0o001)
def find_program(prog):
path = os.environ.get("PATH", "").split(os.pathsep)
if sys.platform == "win32":
prog = "%s.exe" % prog
if hasattr(sys, "frozen"): # a binary (py2exe) build..
# Outlook plugin puts executables in (for example):
# C:/Program Files/SpamBayes/bin
# so add that directory to the path and make sure we
# look for a file ending in ".exe".
if sys.frozen == "dll":
import win32api
sentinal = win32api.GetModuleFileName(sys.frozendllhandle)
else:
sentinal = sys.executable
# os.popen() trying to quote both the program and argv[1] fails.
# So just use the short version.
# For the sake of safety, in a binary build we *only* look in
# our bin dir.
path = [win32api.GetShortPathName(os.path.dirname(sentinal))]
else:
# a source build - for testing, allow it in SB package dir.
import spambayes
path.insert(0, os.path.abspath(spambayes.__path__[0]))
for directory in path:
program = os.path.join(directory, prog)
if os.path.exists(program) and is_executable(program):
return program
return ""
def imconcatlr(left, right):
"""Concatenate two images left to right."""
w1, h1 = left.size
w2, h2 = right.size
result = Image.new("RGB", (w1 + w2, max(h1, h2)))
result.paste(left, (0, 0))
result.paste(right, (w1, 0))
return result
def imconcattb(upper, lower):
"""Concatenate two images top to bottom."""
w1, h1 = upper.size
w2, h2 = lower.size
result = Image.new("RGB", (max(w1, w2), h1 + h2))
result.paste(upper, (0, 0))
result.paste(lower, (0, h1))
return result
def PIL_decode_parts(parts):
"""Decode and assemble a bunch of images using PIL."""
tokens = set()
rows = []
max_image_size = options["Tokenizer", "max_image_size"]
for part in parts:
# See 'image_large_size_attribute' above - the provider may have seen
# an image, but optimized the fact we don't bother processing large
# images.
nbytes = getattr(part, image_large_size_attribute, None)
if nbytes is None: # no optimization - process normally...
try:
bytes = part.get_payload(decode=True)
nbytes = len(bytes)
except:
tokens.add("invalid-image:%s" % part.get_content_type())
continue
else:
# optimization should not have remove images smaller than our max
assert nbytes > max_image_size, (len(bytes), max_image_size)
if nbytes > max_image_size:
tokens.add("image:big")
continue # assume it's just a picture for now
# We're dealing with spammers and virus writers here. Who knows
# what garbage they will call a GIF image to entice you to open
# it?
try:
image = Image.open(io.StringIO(bytes))
image.load()
except:
# Any error whatsoever is reason for not looking further at
# the image.
tokens.add("invalid-image:%s" % part.get_content_type())
continue
else:
# Spammers are now using GIF image sequences. From examining a
# miniscule set of multi-frame GIFs it appears the frame with
# the fewest number of background pixels is the one with the
# text content.
if "duration" in image.info:
# Big assumption? I don't know. If the image's info dict
# has a duration key assume it's a multi-frame image. This
# should save some needless construction of pixel
# histograms for single-frame images.
bgpix = 1e17 # ridiculously large number of pixels
try:
for frame in ImageSequence.Iterator(image):
# Assume the pixel with the largest value is the
# background.
bg = max(frame.histogram())
if bg < bgpix:
image = frame
bgpix = bg
# I've empirically determined:
# * ValueError => GIF image isn't multi-frame.
# * IOError => Decoding error
except IOError:
tokens.add("invalid-image:%s" % part.get_content_type())
continue
except ValueError:
pass
image = image.convert("RGB")
if not rows:
# first image
rows.append(image)
elif image.size[1] != rows[-1].size[1]:
# new image, different height => start new row
rows.append(image)
else:
# new image, same height => extend current row
rows[-1] = imconcatlr(rows[-1], image)
if not rows:
return [], tokens
# now concatenate the resulting row images top-to-bottom
full_image, rows = rows[0], rows[1:]
for image in rows:
full_image = imconcattb(full_image, image)
fd, pnmfile = tempfile.mkstemp('-spambayes-image')
os.close(fd)
full_image.save(open(pnmfile, "wb"), "PPM")
return [pnmfile], tokens
class OCREngine(object):
"""Base class for an OCR "engine" that extracts text. Ideally would
also deal with image format (as different engines will have different
requirements), but all currently supported ones deal with the PNM
formats (ppm/pgm/pbm)
"""
engine_name = None # sub-classes should override.
def __init__(self):
pass
def is_enabled(self):
"""Return true if this engine is able to be used. Note that
returning true only means it is *capable* of being used - not that
it is enabled. eg, it should check the program is needs to use
is installed, etc.
"""
raise NotImplementedError
def extract_text(self, pnmfiles):
"""Extract the text as an unprocessed stream (but as a string).
Typically this will be the raw output from the OCR engine.
"""
raise NotImplementedError
class OCRExecutableEngine(OCREngine):
"""Uses a simple executable that writes to stdout to extract the text"""
engine_name = None
def __init__(self):
# we go looking for the program first use and cache its location
self._program = None
OCREngine.__init__(self)
def is_enabled(self):
return self.program is not None
def get_program(self):
# by default, executable is same as engine name
if not self._program:
self._program = find_program(self.engine_name)
return self._program
program = property(get_program)
def get_command_line(self, pnmfile):
raise NotImplementedError("base classes must override")
def extract_text(self, pnmfile):
# Generically reads output from stdout.
assert self.is_enabled(), "I'm not working!"
cmdline = self.get_command_line(pnmfile)
ocr = os.popen(cmdline)
ret = ocr.read()
exit_code = ocr.close()
if exit_code:
raise SystemError("%s failed with exit code %s" %
(self.engine_name, exit_code))
return ret
class OCREngineOCRAD(OCRExecutableEngine):
engine_name = "ocrad"
def get_command_line(self, pnmfile):
scale = options["Tokenizer", "ocrad_scale"] or 1
charset = options["Tokenizer", "ocrad_charset"]
return '%s -s %s -c %s -f "%s" 2>%s' % \
(self.program, scale, charset, pnmfile, os.path.devnull)
class OCREngineGOCR(OCRExecutableEngine):
engine_name = "gocr"
def get_command_line(self, pnmfile):
return '%s "%s" 2>%s' % (self.program, pnmfile, os.path.devnull)
# This lists all engines, with the first listed that is enabled winning.
# Matched with the engine name, as specified in Options.py, via the
# 'engine_name' attribute on the class.
_ocr_engines = [
OCREngineGOCR,
OCREngineOCRAD,
]
def get_engine(engine_name):
if not engine_name:
candidates = _ocr_engines
else:
for e in _ocr_engines:
if e.engine_name == engine_name:
candidates = [e]
break
else:
candidates = []
for candidate in candidates:
engine = candidate()
if engine.is_enabled():
return engine
return None
class ImageStripper:
def __init__(self, cachefile=""):
self.cachefile = os.path.expanduser(cachefile)
if os.path.exists(self.cachefile):
self.cache = pickle_read(self.cachefile)
else:
self.cache = {}
self.misses = self.hits = 0
if self.cachefile:
atexit.register(self.close)
self.engine = None
def extract_ocr_info(self, pnmfiles):
assert self.engine, "must have an engine!"
textbits = []
tokens = set()
for pnmfile in pnmfiles:
preserve = False
fhash = md5(open(pnmfile).read()).hexdigest()
if fhash in self.cache:
self.hits += 1
ctext, ctokens = self.cache[fhash]
else:
self.misses += 1
if self.engine.program:
try:
ctext = self.engine.extract_text(pnmfile).lower()
except SystemError as msg:
print(msg, file=sys.stderr)
preserve = True
ctext = ""
else:
# We should not get here if no OCR is enabled. If it
# is enabled and we have no program, its OK to spew lots
# of warnings - they should either disable OCR (it is by
# default), or fix their config.
print("No OCR program '%s' available - can't get text!" \
% (self.engine.engine_name,), file=sys.stderr)
ctext = ""
ctokens = set()
if not ctext.strip():
# Lots of spam now contains images in which it is
# difficult or impossible (using ocrad) to find any
# text. Make a note of that.
ctokens.add("image-text:no text found")
else:
nlines = len(ctext.strip().split("\n"))
if nlines:
ctokens.add("image-text-lines:%d" % int(log2(nlines)))
self.cache[fhash] = (ctext, ctokens)
textbits.append(ctext)
tokens |= ctokens
if not preserve:
os.unlink(pnmfile)
return "\n".join(textbits), tokens
def analyze(self, engine_name, parts):
# check engine hasn't changed...
if self.engine is not None and self.engine.engine_name != engine_name:
self.engine = None
# check engine exists and is valid
if self.engine is None:
self.engine = get_engine(engine_name)
if self.engine is None:
# We only get here if explicitly enabled - spewing msgs is ok.
print("invalid engine name '%s' - OCR disabled" \
% (engine_name,), file=sys.stderr)
return "", set()
if not parts:
return "", set()
if Image is not None:
pnmfiles, tokens = PIL_decode_parts(parts)
else:
return "", set()
if pnmfiles:
text, new_tokens = self.extract_ocr_info(pnmfiles)
return text, tokens | new_tokens
return "", tokens
def close(self):
if options["globals", "verbose"]:
print("saving", len(self.cache), end=' ', file=sys.stderr)
print("items to", self.cachefile, end=' ', file=sys.stderr)
if self.hits + self.misses:
print("%.2f%% hit rate" % \
(100 * self.hits / (self.hits + self.misses)), end=' ', file=sys.stderr)
print(file=sys.stderr)
pickle_write(self.cachefile, self.cache)
_cachefile = options["Tokenizer", "crack_image_cache"]
crack_images = ImageStripper(_cachefile).analyze
| 36.81201 | 94 | 0.578764 |
ace04ae7a5167c873a16cb80065bfd3f6a06391d | 2,908 | py | Python | bitbots_misc/bitbots_bringup/scripts/keep_stable_in_sim.py | MosHumanoid/bitbots_thmos_meta | f45ccc362dc689b69027be5b0d000d2a08580de4 | [
"MIT"
] | null | null | null | bitbots_misc/bitbots_bringup/scripts/keep_stable_in_sim.py | MosHumanoid/bitbots_thmos_meta | f45ccc362dc689b69027be5b0d000d2a08580de4 | [
"MIT"
] | null | null | null | bitbots_misc/bitbots_bringup/scripts/keep_stable_in_sim.py | MosHumanoid/bitbots_thmos_meta | f45ccc362dc689b69027be5b0d000d2a08580de4 | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
import rospy
from bitbots_msgs.msg import FootPressure
from gazebo_msgs.msg import ModelStates, ModelState
from gazebo_msgs.srv import SetModelState, SetModelStateRequest
import tf
position = None
roll = None
pitch = None
yaw = None
def state_update(state_msg):
global position
global roll
global pitch
global yaw
global ball_pose
global ball_twist
index = 0
for name in state_msg.name:
if name == "/":
position = state_msg.pose[index].position
orientation = state_msg.pose[index].orientation
quaternion = (
orientation.x,
orientation.y,
orientation.z,
orientation.w)
euler = tf.transformations.euler_from_quaternion(quaternion)
roll = euler[0]
pitch = euler[1]
yaw = euler[2]
elif name == "teensize_ball":
ball_pose = state_msg.pose[index]
ball_twist = state_msg.twist[index]
index += 1
if __name__ == "__main__":
rospy.init_node("keep_stable_sim")
rospy.wait_for_service("/gazebo/set_model_state")
set_state = rospy.ServiceProxy("/gazebo/set_model_state", SetModelState)
goal_subscriber = rospy.Subscriber("/gazebo/model_states", ModelStates, state_update, tcp_nodelay=True)
request = SetModelStateRequest()
request.model_state.model_name = "/"
ball_request = SetModelStateRequest()
ball_request.model_state.model_name = "teensize_ball"
# wait because we want to be called
rospy.sleep(1.0)
rate = rospy.Rate(10)
while not rospy.is_shutdown():
try:
# check if we have values already, otherwise we will do math with none
if(yaw):
request.model_state.pose.position = position
request.model_state.pose.position.z = 0.43 # the robot is not and will not be ready for take off.
quaternion = tf.transformations.quaternion_from_euler(0, 0, yaw)
request.model_state.pose.orientation.x = quaternion[0]
request.model_state.pose.orientation.y = quaternion[1]
request.model_state.pose.orientation.z = quaternion[2]
request.model_state.pose.orientation.w = quaternion[3]
set_state(request)
if ball_pose:
ball_request.model_state.pose = ball_pose
ball_request.model_state.pose.position.z = 0.095
ball_request.model_state.twist = ball_twist
set_state(ball_request)
rate.sleep()
except rospy.exceptions.ROSTimeMovedBackwardsException:
rospy.logwarn(
"We moved backwards in time. I hope you just resetted the simulation. If not there is something wrong")
except rospy.exceptions.ROSInterruptException:
exit()
| 33.425287 | 115 | 0.638239 |
ace04cf6de6993c1a0d2f498b373235a5b9ed67a | 456 | py | Python | src/api_handler/get_products.py | aws-samples/serverless-python-demo | 83acd05b97436bfca4af8b0f0234796113bfc05e | [
"MIT-0"
] | 2 | 2022-03-08T14:20:32.000Z | 2022-03-09T01:28:51.000Z | src/api_handler/get_products.py | aws-samples/serverless-python-demo | 83acd05b97436bfca4af8b0f0234796113bfc05e | [
"MIT-0"
] | null | null | null | src/api_handler/get_products.py | aws-samples/serverless-python-demo | 83acd05b97436bfca4af8b0f0234796113bfc05e | [
"MIT-0"
] | null | null | null | ##Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
##SPDX-License-Identifier: MIT-0
import os
import json
from .store.data_store import ProductStore
product_store = ProductStore(os.getenv("TABLE"))
def lambda_handler(event, context):
products = product_store.get_products()
return {
"statusCode": 200,
"headers": {"Content-Type": "application/json"},
"body": json.dumps({"products": products}),
}
| 24 | 68 | 0.688596 |
ace04e824a709064bf70bb9d50cc8cf91f5c25e8 | 3,248 | py | Python | oldtoronto/devserver.py | patcon/oldto | 44c099550a4e3cfafa85afbaebd3cd6c33325891 | [
"Apache-2.0"
] | 22 | 2018-04-25T22:03:53.000Z | 2021-07-13T18:43:23.000Z | oldtoronto/devserver.py | patcon/oldto | 44c099550a4e3cfafa85afbaebd3cd6c33325891 | [
"Apache-2.0"
] | 17 | 2018-04-30T14:04:08.000Z | 2022-02-13T19:52:44.000Z | oldtoronto/devserver.py | patcon/oldto | 44c099550a4e3cfafa85afbaebd3cd6c33325891 | [
"Apache-2.0"
] | 7 | 2018-05-08T23:32:44.000Z | 2022-01-27T17:49:30.000Z | #!/usr/bin/env python
"""Run a dev server for the OldTO API.
This is useful for iterating on geocoding since it will reload the GeoJSON file if it changes.
Supported endpoints:
- /api/oldtoronto/lat_lng_counts?var=lat_lons
- /api/oldtoronto/by_location?lat=43.651501&lng=-79.359842
- /api/layer/oldtoronto/86514
"""
import argparse
from collections import defaultdict, Counter
import copy
import json
import os
from flask import Flask, abort, jsonify, request, Response
from haversine import haversine
geojson_file = None # filled in in __main__
mtime = 0 # last modified time
features = []
def old_toronto_key(lat, lng):
""""Return a key for a record that matches the old toronto convention of the
concatenation of the lat and lng rounded to 6 decimals.
Rounding is done differently in JavaScript from Python - 3.499999 rounds to
3.4 in Python, 3.5 in JavaScript, hence the workaround to first round to 7
decimals and then to 6.
"""
def round6(f):
return round(round(f, 7), 6)
lat = round6(lat)
lng = round6(lng)
return f'{lat:2.6f},{lng:2.6f}'
app = Flask(__name__)
# Check for changes to the GeoJSON file before every request.
@app.before_request
def maybe_load_features():
global features, mtime
new_mtime = os.stat(geojson_file).st_mtime
if new_mtime > mtime:
mtime = new_mtime
# Filter out the null geometries ahead of time.
features = [
f
for f in json.load(open(args.geojson))['features']
if f['geometry']
]
print(f'Loaded {len(features)} features from {geojson_file}')
@app.route('/api/oldtoronto/lat_lng_counts')
def lat_lng_counts():
counts = defaultdict(Counter)
for f in features:
lng, lat = f['geometry']['coordinates']
year = f['properties']['date'] or ''
counts[old_toronto_key(lat, lng)][year] += 1
var = request.args.get('var')
js = 'var %s=%s' % (var, json.dumps(counts))
return Response(js, mimetype='text/javascript')
@app.route('/api/oldtoronto/by_location')
def by_location():
def poi_to_rec(poi):
props = copy.deepcopy(poi['properties'])
image = props.pop('image')
image['image_url'] = image.pop('url')
return dict(image, id=poi['id'], **props)
pt = (float(request.args.get('lat')), float(request.args.get('lng')))
results = {
f['id']: poi_to_rec(f)
for f in features
if haversine(pt, f['geometry']['coordinates'][::-1]) < 0.005
}
return jsonify(results)
@app.route('/api/layer/oldtoronto/<photo_id>')
def by_photo_id(photo_id):
feature = [f for f in features if f['id'] == photo_id]
if feature:
return jsonify(feature[0])
else:
abort(404)
if __name__ == '__main__':
parser = argparse.ArgumentParser('Run a simple API server for Old Toronto')
parser.add_argument('--port', type=int, help='Port on which to serve.', default=8081)
parser.add_argument('geojson', type=str, default='data/images.geojson',
help='Path to images.geojson')
args = parser.parse_args()
geojson_file = args.geojson
maybe_load_features()
app.run(host='0.0.0.0', port=args.port, debug=True)
| 29.261261 | 94 | 0.656404 |
ace04f33c3554ecfb1e98fa09b1670b1b791b43b | 2,318 | py | Python | apps/tasker/builders/lib_helpers.py | hugoseabra/redmine-task-generator | b5ce1764f1c7588a7c82b25f7dd4bf07d1c105cf | [
"MIT"
] | null | null | null | apps/tasker/builders/lib_helpers.py | hugoseabra/redmine-task-generator | b5ce1764f1c7588a7c82b25f7dd4bf07d1c105cf | [
"MIT"
] | 4 | 2021-03-30T14:04:56.000Z | 2021-06-10T19:40:52.000Z | apps/tasker/builders/lib_helpers.py | hugoseabra/redmine-task-generator | b5ce1764f1c7588a7c82b25f7dd4bf07d1c105cf | [
"MIT"
] | null | null | null | import json
import os
from django.conf import settings
from .task_builders.task_content_builders import TaskContentBuilder, ScoreField
CONF_FILE = os.path.join(settings.BASE_DIR, 'conf', 'ped.json')
CONF_CONTENT = json.load(open(CONF_FILE))
def get_implementation_task(lib_name,
pre_note=None,
content=None,
post_note=None,
estimated_hours: int = None,
target_version_id: str = None,
score_field: dict = None) -> TaskContentBuilder:
data = CONF_CONTENT.get('implementation')
if score_field:
score_field = ScoreField(**score_field)
task = TaskContentBuilder(
name='[LIB] Implementation task',
subject=data['subject'],
description=data['description'],
score_field=score_field,
estimated_hours=estimated_hours,
target_version_id=target_version_id,
)
task.add_content(key='lib_name', value=lib_name)
if pre_note:
task.add_content(key='pre_note', value=pre_note)
if content:
task.add_content(key='content', value=content)
if post_note:
task.add_content(key='post_note', value=post_note)
return task
def get_thirdy_party_task(lib_name,
pre_note=None,
content=None,
post_note=None,
estimated_hours: int = None,
target_version_id: str = None,
score_field: dict = None) -> TaskContentBuilder:
data = CONF_CONTENT.get('implementation')
if score_field:
score_field = ScoreField(**score_field)
task = TaskContentBuilder(
name='[LIB] Third party task',
subject=data['subject'],
description=data['description'],
score_field=score_field,
estimated_hours=estimated_hours,
target_version_id=target_version_id,
)
task.add_content(key='lib_name', value=lib_name)
if pre_note:
task.add_content(key='pre_note', value=pre_note)
if content:
task.add_content(key='content', value=content)
if post_note:
task.add_content(key='post_note', value=post_note)
return task
| 29.341772 | 79 | 0.603538 |
ace04f4aff45e3d38d4a2d3eb1566b0e7f1c990e | 1,911 | py | Python | test/Install/INSTALLSTR.py | ivankravets/scons | 8f79f4c6c0ce87236f5633dcb7bc08222622b70a | [
"MIT"
] | 3 | 2018-09-13T04:41:31.000Z | 2020-07-03T09:25:08.000Z | test/Install/INSTALLSTR.py | ivankravets/scons | 8f79f4c6c0ce87236f5633dcb7bc08222622b70a | [
"MIT"
] | 2 | 2021-04-12T16:17:32.000Z | 2021-04-12T18:59:18.000Z | test/Install/INSTALLSTR.py | ivankravets/scons | 8f79f4c6c0ce87236f5633dcb7bc08222622b70a | [
"MIT"
] | 2 | 2018-09-13T04:41:35.000Z | 2020-04-27T20:46:58.000Z | #!/usr/bin/env python
#
# __COPYRIGHT__
#
# 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.
#
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
"""
Test that the $INSTALLSTR variable is displayed when we install a file.
"""
import os.path
import TestSCons
test = TestSCons.TestSCons()
test.subdir('install')
# Check that spaces aren't stripped in INSTALLSTR by using
# extra whitespace in the string (issue 2018)
test.write('SConstruct', """\
DefaultEnvironment(tools=[])
env = Environment(tools=[], INSTALLSTR='INSTALL $SOURCE => $TARGET!')
env.Install('install', 'file')
""")
test.write('file', "file\n")
test.run(stdout=test.wrap_stdout("""\
INSTALL file => %s!
""") % os.path.join('install', 'file'))
test.must_match(['install', 'file'], "file\n")
test.pass_test()
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4:
| 30.822581 | 73 | 0.744636 |
ace0504eab1f37c781d9bce078eb6b98ff8c3fae | 4,105 | py | Python | benchmark/startQiskit_Class2991.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | benchmark/startQiskit_Class2991.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | benchmark/startQiskit_Class2991.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | # qubit number=4
# total number=32
import cirq
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import BasicAer, execute, transpile
from pprint import pprint
from qiskit.test.mock import FakeVigo
from math import log2
import numpy as np
import networkx as nx
def bitwise_xor(s: str, t: str) -> str:
length = len(s)
res = []
for i in range(length):
res.append(str(int(s[i]) ^ int(t[i])))
return ''.join(res[::-1])
def bitwise_dot(s: str, t: str) -> str:
length = len(s)
res = 0
for i in range(length):
res += int(s[i]) * int(t[i])
return str(res % 2)
def build_oracle(n: int, f) -> QuantumCircuit:
# implement the oracle O_f
# NOTE: use multi_control_toffoli_gate ('noancilla' mode)
# https://qiskit.org/documentation/_modules/qiskit/aqua/circuits/gates/multi_control_toffoli_gate.html
# https://quantumcomputing.stackexchange.com/questions/3943/how-do-you-implement-the-toffoli-gate-using-only-single-qubit-and-cnot-gates
# https://quantumcomputing.stackexchange.com/questions/2177/how-can-i-implement-an-n-bit-toffoli-gate
controls = QuantumRegister(n, "ofc")
target = QuantumRegister(1, "oft")
oracle = QuantumCircuit(controls, target, name="Of")
for i in range(2 ** n):
rep = np.binary_repr(i, n)
if f(rep) == "1":
for j in range(n):
if rep[j] == "0":
oracle.x(controls[j])
oracle.mct(controls, target[0], None, mode='noancilla')
for j in range(n):
if rep[j] == "0":
oracle.x(controls[j])
# oracle.barrier()
return oracle
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.x(input_qubit[3]) # number=1
prog.rx(-1.9352210746113125,input_qubit[3]) # number=14
prog.cx(input_qubit[1],input_qubit[2]) # number=22
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=3
prog.h(input_qubit[3]) # number=4
prog.y(input_qubit[2]) # number=13
prog.y(input_qubit[2]) # number=28
prog.rx(0.13823007675795101,input_qubit[2]) # number=24
prog.h(input_qubit[0]) # number=5
oracle = build_oracle(n-1, f)
prog.append(oracle.to_gate(),[input_qubit[i] for i in range(n-1)]+[input_qubit[n-1]])
prog.h(input_qubit[1]) # number=6
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=9
prog.rx(-1.9069467407290044,input_qubit[2]) # number=20
prog.h(input_qubit[3]) # number=21
prog.h(input_qubit[3]) # number=27
prog.y(input_qubit[2]) # number=10
prog.h(input_qubit[1]) # number=17
prog.cz(input_qubit[3],input_qubit[1]) # number=18
prog.h(input_qubit[1]) # number=19
prog.y(input_qubit[2]) # number=11
prog.h(input_qubit[0]) # number=29
prog.cz(input_qubit[1],input_qubit[0]) # number=30
prog.h(input_qubit[0]) # number=31
prog.cx(input_qubit[1],input_qubit[0]) # number=16
prog.z(input_qubit[3]) # number=23
prog.y(input_qubit[1]) # number=25
prog.y(input_qubit[1]) # number=26
# circuit end
return prog
if __name__ == '__main__':
a = "111"
b = "0"
f = lambda rep: bitwise_xor(bitwise_dot(a, rep), b)
prog = make_circuit(4,f)
backend = BasicAer.get_backend('statevector_simulator')
sample_shot =8000
info = execute(prog, backend=backend).result().get_statevector()
qubits = round(log2(len(info)))
info = {
np.binary_repr(i, qubits): round((info[i]*(info[i].conjugate())).real,3)
for i in range(2 ** qubits)
}
backend = FakeVigo()
circuit1 = transpile(prog,backend,optimization_level=2)
writefile = open("../data/startQiskit_Class2991.csv","w")
print(info,file=writefile)
print("results end", file=writefile)
print(circuit1.__len__(),file=writefile)
print(circuit1,file=writefile)
writefile.close()
| 34.208333 | 140 | 0.647016 |
ace051738256fb9d2cbb05f20f96816a4469b75d | 3,500 | py | Python | official/transformer/v2/transformer_layers_test.py | zcdzcdzcd/models | a31b526a7617a152a138a865b5689bf5b59f655d | [
"Apache-2.0"
] | 5 | 2020-11-16T06:26:19.000Z | 2022-03-27T02:01:40.000Z | official/transformer/v2/transformer_layers_test.py | zcdzcdzcd/models | a31b526a7617a152a138a865b5689bf5b59f655d | [
"Apache-2.0"
] | 6 | 2021-06-08T21:30:48.000Z | 2022-03-12T00:29:00.000Z | official/transformer/v2/transformer_layers_test.py | zcdzcdzcd/models | a31b526a7617a152a138a865b5689bf5b59f655d | [
"Apache-2.0"
] | 7 | 2017-07-01T22:47:51.000Z | 2021-05-15T10:48:22.000Z | # Copyright 2019 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for layers in Transformer."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from official.transformer.v2 import attention_layer
from official.transformer.v2 import embedding_layer
from official.transformer.v2 import ffn_layer
from official.transformer.v2 import metrics
class TransformerLayersTest(tf.test.TestCase):
def test_attention_layer(self):
hidden_size = 64
num_heads = 4
dropout = 0.5
dim_per_head = hidden_size // num_heads
layer = attention_layer.SelfAttention(hidden_size, num_heads, dropout)
self.assertDictEqual(layer.get_config(), {
"hidden_size": hidden_size,
"num_heads": num_heads,
"attention_dropout": dropout,
})
length = 2
x = tf.ones([1, length, hidden_size])
bias = tf.ones([1])
cache = {
"k": tf.zeros([1, 0, num_heads, dim_per_head]),
"v": tf.zeros([1, 0, num_heads, dim_per_head]),
}
y = layer(x, bias, training=True, cache=cache)
self.assertEqual(y.shape, (1, length, 64,))
self.assertEqual(cache["k"].shape, (1, length, num_heads, dim_per_head,))
self.assertEqual(cache["v"].shape, (1, length, num_heads, dim_per_head,))
def test_embedding_shared_weights(self):
vocab_size = 50
hidden_size = 64
length = 2
layer = embedding_layer.EmbeddingSharedWeights(vocab_size, hidden_size)
self.assertDictEqual(layer.get_config(), {
"vocab_size": 50,
"hidden_size": 64,
})
idx = tf.ones([1, length], dtype="int32")
y = layer(idx)
self.assertEqual(y.shape, (1, length, hidden_size,))
x = tf.ones([1, length, hidden_size])
output = layer(x, "linear")
self.assertEqual(output.shape, (1, length, vocab_size,))
def test_feed_forward_network(self):
hidden_size = 64
filter_size = 32
relu_dropout = 0.5
layer = ffn_layer.FeedForwardNetwork(hidden_size, filter_size, relu_dropout)
self.assertDictEqual(layer.get_config(), {
"hidden_size": hidden_size,
"filter_size": filter_size,
"relu_dropout": relu_dropout,
})
length = 2
x = tf.ones([1, length, hidden_size])
y = layer(x, training=True)
self.assertEqual(y.shape, (1, length, hidden_size,))
def test_metric_layer(self):
vocab_size = 50
logits = tf.keras.layers.Input((None, vocab_size),
dtype="float32",
name="logits")
targets = tf.keras.layers.Input((None,), dtype="int64", name="targets")
output_logits = metrics.MetricLayer(vocab_size)([logits, targets])
self.assertEqual(output_logits.shape.as_list(), [None, None, vocab_size,])
if __name__ == "__main__":
tf.compat.v1.enable_v2_behavior()
tf.test.main()
| 35.353535 | 80 | 0.669714 |
ace0517f1943db2af4eb3440ab73d0b8d4a3f56b | 3,506 | py | Python | setup.py | fif911/trello3_little_bit_updated | baf0275c5a89b3bcf9c1544897cbe25fafbc53d0 | [
"BSD-2-Clause"
] | 16 | 2016-01-19T17:02:24.000Z | 2020-02-20T19:23:32.000Z | setup.py | fif911/trello3_little_bit_updated | baf0275c5a89b3bcf9c1544897cbe25fafbc53d0 | [
"BSD-2-Clause"
] | 3 | 2016-02-10T14:17:58.000Z | 2016-07-26T01:31:54.000Z | setup.py | fif911/trello3_little_bit_updated | baf0275c5a89b3bcf9c1544897cbe25fafbc53d0 | [
"BSD-2-Clause"
] | 7 | 2016-02-09T23:47:00.000Z | 2021-06-05T17:03:22.000Z | from distutils.core import setup
from textwrap import dedent
setup(name='trello',
version='0.9.2',
packages=['trello'],
license=dedent("""\
Copyright (c) 2012, Fog Creek Software, Inc.
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.
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.
"""),
description='Python library for interacting with the Trello API',
long_description=dedent("""\
Python Trello API Wrapper
--------------------------
This Python API is simply a wrapper around the Trello API
Getting Started:
----------------
To use the Trello API, install the package either by downloading the source and running
$ python setup.py install
or by using pip
$ pip install trello
Documentation:
--------------
You can find documentation for the Python API at:
http://packages.python.org/trello/
And documentation for the Trello API at:
https://trello.com/docs/api/
"""),
author='Fog Creek Software',
author_email='customer-service@fogcreek.com',
maintainer='Fog Creek Software',
maintainer_email='customer-service@fogcreek.com',
url='https://trello.com/',
download_url='https://developers.kilnhg.com/Repo/Trello/Group/TrelloPy',
install_requires=['requests>=0.9.1'],
requires='requests',
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Natural Language :: English',
'Operating System :: MacOS :: MacOS X',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'Operating System :: POSIX :: BSD',
'Operating System :: POSIX :: Linux',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Utilities',
],
)
| 41.247059 | 96 | 0.625214 |
ace052accaa592168fb8f85fde284bb267786c58 | 798 | py | Python | plots/plot_wp_boundary.py | EderVs/Voronoi-Diagrams | 6e69f9b6eb516dee12d66f187cf267a7b527da5f | [
"MIT"
] | 3 | 2021-11-12T17:43:08.000Z | 2022-01-03T02:47:34.000Z | plots/plot_wp_boundary.py | EderVs/Voronoi-Diagrams | 6e69f9b6eb516dee12d66f187cf267a7b527da5f | [
"MIT"
] | 3 | 2021-11-19T20:12:31.000Z | 2021-11-19T20:14:39.000Z | plots/plot_wp_boundary.py | EderVs/Voronoi-Diagrams | 6e69f9b6eb516dee12d66f187cf267a7b527da5f | [
"MIT"
] | null | null | null | """Plot WeightedPointBoundary."""
from voronoi_diagrams.models import (
Point,
WeightedSite,
WeightedPointBisector,
WeightedPointBoundary,
)
from plots.plot_utils.models.boundaries import plot_boundary
from plotly import graph_objects as go
from decimal import Decimal
p1 = Point(Decimal("2"), Decimal("10.7"))
w1 = Decimal("3.1")
p2 = Point(Decimal("6"), Decimal("10.6"))
w2 = Decimal("0")
s1 = WeightedSite(p1.x, p1.y, w1)
s2 = WeightedSite(p2.x, p2.y, w2)
b = WeightedPointBisector([s1, s2])
b_plus = WeightedPointBoundary(b, True)
b_minus = WeightedPointBoundary(b, False)
figure = go.Figure()
xlim = (-100, 100)
ylim = (-100, 100)
plot_boundary(figure, b_minus, xlim, ylim, WeightedPointBisector)
plot_boundary(figure, b_plus, xlim, ylim, WeightedPointBisector)
figure.show()
| 29.555556 | 65 | 0.735589 |
ace052e10b01b0bc2e82551fa064c6ee0efc1ab8 | 4,119 | py | Python | .venv/lib/python3.8/site-packages/pandas_datareader/av/time_series.py | eo1989/VectorBTanalysis | bea3deaf2ee3fc114b308146f2af3e4f35f70197 | [
"MIT"
] | 1 | 2021-11-16T19:06:56.000Z | 2021-11-16T19:06:56.000Z | .venv/lib/python3.8/site-packages/pandas_datareader/av/time_series.py | eo1989/VectorBTanalysis | bea3deaf2ee3fc114b308146f2af3e4f35f70197 | [
"MIT"
] | null | null | null | .venv/lib/python3.8/site-packages/pandas_datareader/av/time_series.py | eo1989/VectorBTanalysis | bea3deaf2ee3fc114b308146f2af3e4f35f70197 | [
"MIT"
] | 1 | 2021-11-16T19:06:53.000Z | 2021-11-16T19:06:53.000Z | import datetime as dt
from pandas_datareader.av import AlphaVantage
class AVTimeSeriesReader(AlphaVantage):
"""
Returns DataFrame of the Alpha Vantage Stock Time Series endpoints
.. versionadded:: 0.7.0
Parameters
----------
symbols : string
Single stock symbol (ticker)
start : string, int, date, datetime, Timestamp
Starting date. Parses many different kind of date
representations (e.g., 'JAN-01-2010', '1/1/10', 'Jan, 1, 1980'). Defaults to
20 years before current date.
end : string, int, date, datetime, Timestamp
Ending date
retry_count : int, default 3
Number of times to retry query request.
pause : int, default 0.1
Time, in seconds, to pause between consecutive queries of chunks. If
single value given for symbol, represents the pause between retries.
session : Session, default None
requests.sessions.Session instance to be used
api_key : str, optional
AlphaVantage API key . If not provided the environmental variable
ALPHAVANTAGE_API_KEY is read. The API key is *required*.
"""
_FUNC_TO_DATA_KEY = {
"TIME_SERIES_DAILY": "Time Series (Daily)",
"TIME_SERIES_DAILY_ADJUSTED": "Time Series (Daily)",
"TIME_SERIES_WEEKLY": "Weekly Time Series",
"TIME_SERIES_WEEKLY_ADJUSTED": "Weekly Adjusted Time Series",
"TIME_SERIES_MONTHLY": "Monthly Time Series",
"TIME_SERIES_MONTHLY_ADJUSTED": "Monthly Adjusted Time Series",
"TIME_SERIES_INTRADAY": "Time Series (1min)",
"FX_DAILY": "Time Series FX (Daily)",
}
def __init__(
self,
symbols=None,
function="TIME_SERIES_DAILY",
start=None,
end=None,
retry_count=3,
pause=0.1,
session=None,
chunksize=25,
api_key=None,
):
self._func = function
super(AVTimeSeriesReader, self).__init__(
symbols=symbols,
start=start,
end=end,
retry_count=retry_count,
pause=pause,
session=session,
api_key=api_key,
)
@property
def default_start_date(self):
d_days = 3 if self.intraday else 365 * 20
return dt.datetime.today() - dt.timedelta(days=d_days)
@property
def function(self):
return self._func
@property
def intraday(self):
return True if self.function == "TIME_SERIES_INTRADAY" else False
@property
def forex(self):
return True if self.function == "FX_DAILY" else False
@property
def output_size(self):
""" Used to limit the size of the Alpha Vantage query when
possible.
"""
delta = dt.datetime.now() - self.start
return "compact" if delta.days < 80 and not self.intraday else "full"
@property
def data_key(self):
return self._FUNC_TO_DATA_KEY[self.function]
@property
def params(self):
p = {
"function": self.function,
"apikey": self.api_key,
"outputsize": self.output_size,
}
if self.intraday:
p.update({"interval": "1min"})
if self.forex:
p.update({"from_symbol": self.symbols.split("/")[0]})
p.update({"to_symbol": self.symbols.split("/")[1]})
else:
p.update({"symbol": self.symbols})
return p
def _read_lines(self, out):
data = super(AVTimeSeriesReader, self)._read_lines(out)
# reverse since alphavantage returns descending by date
data = data[::-1]
start_str = self.start.strftime("%Y-%m-%d")
end_str = self.end.strftime("%Y-%m-%d")
data = data.loc[start_str:end_str]
if data.empty:
raise ValueError("Please input a valid date range")
else:
for column in data.columns:
if column == "volume":
data[column] = data[column].astype("int64")
else:
data[column] = data[column].astype("float64")
return data
| 31.930233 | 84 | 0.596018 |
ace052f1eb49e2abc8db183599b482b04b6b577d | 2,044 | py | Python | services/users/update.py | CPSSD/rabble | 88ad5f4cfd49c00037ffdd0f0b5d463dcbf299c9 | [
"MIT"
] | 3 | 2020-03-17T23:18:39.000Z | 2021-03-06T02:56:46.000Z | services/users/update.py | CPSSD/rabble | 88ad5f4cfd49c00037ffdd0f0b5d463dcbf299c9 | [
"MIT"
] | 3 | 2020-03-21T08:47:34.000Z | 2020-05-11T21:56:56.000Z | services/users/update.py | CPSSD/rabble | 88ad5f4cfd49c00037ffdd0f0b5d463dcbf299c9 | [
"MIT"
] | 1 | 2020-03-17T14:13:54.000Z | 2020-03-17T14:13:54.000Z | from services.proto import users_pb2
from services.proto import database_pb2
from util import get_user_and_check_pw
import bcrypt
class UpdateHandler:
def __init__(self, logger, db_stub):
self._logger = logger
self._db_stub = db_stub
def _hash_password(self, password):
return bcrypt.hashpw(password.encode('utf-8'),
bcrypt.gensalt())
def Update(self, request, context):
try:
user, err = get_user_and_check_pw(self._logger,
self._db_stub,
request.handle,
request.current_password)
except ValueError as e:
return users_pb2.UpdateUserResponse(
result=users_pb2.UpdateUserResponse.ERROR,
error=str(e),
)
if err != None:
return users_pb2.UpdateUserResponse(
result=users_pb2.UpdateUserResponse.DENIED,
)
pw = None
if request.new_password:
pw = self._hash_password(request.new_password)
update_request = database_pb2.UsersRequest(
request_type=database_pb2.UsersRequest.UPDATE,
match=user,
entry=database_pb2.UsersEntry(
display_name=request.display_name,
password=pw,
bio=request.bio,
private=request.private,
custom_css=request.custom_css,
),
)
db_resp = self._db_stub.Users(update_request)
if db_resp.result_type != database_pb2.UsersResponse.OK:
self._logger.warning("Error update user: %s", db_resp.error)
return users_pb2.CreateUserResponse(
result_type=users_pb2.CreateUserResponse.ERROR,
error=db_resp.error,
)
return users_pb2.UpdateUserResponse(
result=users_pb2.UpdateUserResponse.ACCEPTED,
)
| 33.508197 | 72 | 0.56409 |
ace05396a7fad061af5c62f87af47268e63691af | 1,608 | py | Python | tensorflow_gan/examples/esrgan/eval_test.py | Aerochip7/gan | d3648c0f3996bd9e5564c05a44ff4215e5156cbd | [
"Apache-2.0"
] | null | null | null | tensorflow_gan/examples/esrgan/eval_test.py | Aerochip7/gan | d3648c0f3996bd9e5564c05a44ff4215e5156cbd | [
"Apache-2.0"
] | null | null | null | tensorflow_gan/examples/esrgan/eval_test.py | Aerochip7/gan | d3648c0f3996bd9e5564c05a44ff4215e5156cbd | [
"Apache-2.0"
] | null | null | null | # coding=utf-8
# Copyright 2022 The TensorFlow GAN Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for tfgan.examples.esrgan.eval."""
import collections
import tensorflow as tf
from tensorflow_gan.examples.esrgan import eval_lib
from tensorflow_gan.examples.esrgan import networks
HParams = collections.namedtuple('HParams', [
'num_steps', 'image_dir', 'batch_size', 'num_inception_images',
'eval_real_images', 'hr_dimension', 'scale', 'trunk_size'
])
class EvalTest(tf.test.TestCase):
def setUp(self):
super(EvalTest, self).setUp()
self.hparams = HParams(1, '/content/', 2, 2, True, 256, 4, 11)
d = tf.data.Dataset.from_tensor_slices(tf.random.normal([2, 256, 256, 3]))
def lr(hr):
lr = tf.image.resize(hr, [64, 64], method='bicubic')
return lr, hr
d = d.map(lr)
d = d.batch(2)
self.mock_dataset = d
self.generator = networks.generator_network(self.hparams)
def test_eval(self):
self.assertIsNone(
eval_lib.evaluate(self.hparams, self.generator, self.mock_dataset))
if __name__ == '__main__':
tf.test.main()
| 29.777778 | 78 | 0.714552 |
ace0549e2a60d1e26540eab97e878f80d465f873 | 3,573 | py | Python | tests/test_util.py | danieleteti/simplemonitor | e2cb5c22dd72145035f2e68cd9ce90e77fd147c3 | [
"BSD-3-Clause"
] | null | null | null | tests/test_util.py | danieleteti/simplemonitor | e2cb5c22dd72145035f2e68cd9ce90e77fd147c3 | [
"BSD-3-Clause"
] | null | null | null | tests/test_util.py | danieleteti/simplemonitor | e2cb5c22dd72145035f2e68cd9ce90e77fd147c3 | [
"BSD-3-Clause"
] | null | null | null | # type: ignore
import datetime
import unittest
from simplemonitor import util
class TestUtil(unittest.TestCase):
def test_Config(self):
config_options = {
"test_string": "a string",
"test_int": "3",
"test_[int]": "1,2, 3",
"test_[str]": "a, b,c",
"test_bool1": "1",
"test_bool2": "yes",
"test_bool3": "true",
"test_bool4": "0",
}
self.assertEqual(
util.get_config_option(config_options, "test_string"), "a string"
)
self.assertEqual(
util.get_config_option(config_options, "test_int", required_type="int"), 3
)
self.assertEqual(
util.get_config_option(config_options, "test_[int]", required_type="[int]"),
[1, 2, 3],
)
self.assertEqual(
util.get_config_option(config_options, "test_[str]", required_type="[str]"),
["a", "b", "c"],
)
for bool_test in list(range(1, 4)):
self.assertEqual(
util.get_config_option(
config_options,
"test_bool{0}".format(bool_test),
required_type="bool",
),
True,
)
self.assertEqual(
util.get_config_option(config_options, "test_bool4", required_type="bool"),
False,
)
with self.assertRaises(ValueError):
util.get_config_option(["not a dict"], "")
with self.assertRaises(ValueError):
util.get_config_option(config_options, "missing_value", required=True)
with self.assertRaises(ValueError):
util.get_config_option(config_options, "test_string", required_type="int")
with self.assertRaises(ValueError):
util.get_config_option(config_options, "test_string", required_type="float")
with self.assertRaises(ValueError):
util.get_config_option(
config_options, "test_int", required_type="int", minimum=4
)
with self.assertRaises(ValueError):
util.get_config_option(
config_options, "test_int", required_type="int", maximum=2
)
with self.assertRaises(ValueError):
util.get_config_option(config_options, "test_[str]", required_type="[int]")
with self.assertRaises(ValueError):
util.get_config_option(
config_options,
"test_[str]",
required_type="[str]",
allowed_values=["d"],
)
with self.assertRaises(ValueError):
util.get_config_option(
config_options,
"test_string",
allowed_values=["other string", "other other string"],
)
with self.assertRaises(NotImplementedError):
util.get_config_option(
"not a dict", "doesn't matter", exception=NotImplementedError
)
with self.assertRaises(ValueError):
util.get_config_option(
{"empty_string": ""},
"empty_string",
required_type="str",
allow_empty=False,
)
def test_Format(self):
self.assertEqual(util.format_datetime(None), "")
self.assertEqual(util.format_datetime("a string"), "a string")
self.assertEqual(
util.format_datetime(datetime.datetime(2018, 5, 8, 13, 37, 0)),
"2018-05-08 13:37:00",
)
| 36.835052 | 88 | 0.547719 |
ace0558b87a3c76498a09e01e542c66a8dfd577f | 7,196 | py | Python | rkd/didactic/core.py | iro-upgto/rkd | 7823781ddc81a9dac18fed55080205e8ed68b57b | [
"MIT"
] | null | null | null | rkd/didactic/core.py | iro-upgto/rkd | 7823781ddc81a9dac18fed55080205e8ed68b57b | [
"MIT"
] | null | null | null | rkd/didactic/core.py | iro-upgto/rkd | 7823781ddc81a9dac18fed55080205e8ed68b57b | [
"MIT"
] | null | null | null | """
"""
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import operator, functools
from rkd.didactic.transformations import *
from sympy import *
from sympy.matrices import Matrix,eye
from rkd.abc import *
from rkd.didactic.ws import *
__all__ = ["Robot", "RigidBody2D"]
class Robot(object):
"""
Define a robot-serial-arm given the Denavit-Hartenberg parameters
and joint type, as tuples:
"""
def __init__(self,*args):
self.Ts = [] # Transformation matrices i to i-1
self.type = [] # Joint type -> "r" revolute, "p" prismatic
self.qs = []
for k in args:
self.Ts.append(dh(k[0],k[1],k[2],k[3])) # Compute Ti->i-1
if len(k)>4:
self.type.append(k[4])
else:
self.type.append('r')
if self.type[-1] is "r":
self.qs.append(k[3])
else:
self.qs.append(k[2])
self._dof = len(args) # Degree of freedom
def z(self,i):
"""
z-dir of every i-Frame wrt 0-Frame
"""
if i == 0: return Matrix([[0],[0],[1]])
MTH = eye(4)
for k in range(i):
MTH = MTH*self.Ts[k]
return MTH[:3,2]
def p(self,i):
"""
Position for every i-Frame wrt 0-Frame
"""
if i == 0: return Matrix([[0],[0],[0]])
MTH = eye(4)
for k in range(i):
MTH = MTH*self.Ts[k]
return MTH[:3,3]
@property
def J(self):
"""
Geometric Jacobian matrix
"""
n = self.dof
M_ = zeros(6,n)
for i in range(self.dof):
if self.type[i]=='r':
jp = self.z(i).cross(self.p(n) - self.p(i))
jo = self.z(i)
else:
jp = self.z(i)
jo = zeros(3,1)
jp = jp.col_join(jo)
M_[:,i] = jp
return simplify(M_)
def J_i(self,i):
"""
Geometric Jacobian matrix
"""
n = i
M_ = zeros(6,n)
for i in range(n):
if self.type[i]=='r':
jp = self.z(i).cross(self.p(n) - self.p(i))
jo = self.z(i)
else:
jp = self.z(i)
jo = zeros(3,1)
jp = jp.col_join(jo)
M_[:,i] = jp
return simplify(M_).evalf(6)
@property
def dof(self):
return self._dof
@property
def T(self):
"""
T_n^0
Homogeneous transformation matrix of N-Frame respect to Base-Frame
"""
return simplify(functools.reduce(operator.mul, self.Ts))
def Ti_0(self,i):
return simplify(functools.reduce(operator.mul, self.Ts[:i+1]))
def plot_diagram(self,vals):
#return None
fig = plt.figure()
ax = fig.gca(projection='3d')
Ts = self.Ts
points = []
Ti_0 = []
points.append(zeros(1,3))
for i in range(self.dof):
Ti_0.append(self.Ti_0(i).subs(vals))
points.append((self.Ti_0(i)[:3,3]).subs(vals))
X = [float(k[0]) for k in points]
Y = [float(k[1]) for k in points]
Z = [float(k[2]) for k in points]
ax.plot(X,Y,Z, "o-", color="#778877", lw=3)
ax.plot([0],[0],[0], "mo", markersize=6)
ax.set_axis_off()
ax.view_init(90,0)
px,py,pz = float(X[-1]),float(Y[-1]),float(Z[-1])
dim = max([px,py,pz])
self.draw_uvw(eye(4),ax, dim)
for T in Ti_0:
self.draw_uvw(T, ax, dim)
ax.set_xlim(-dim, dim)
ax.set_ylim(-dim, dim)
ax.set_zlim(-dim, dim)
plt.show()
def draw_uvw(self,H,ax,sz=1):
u = H[:3,0]
v = H[:3,1]
w = H[:3,2]
o = H[:3,3]
L = sz/5
ax.quiver(o[0],o[1],o[2],u[0],u[1],u[2],color="r", length=L)
ax.quiver(o[0],o[1],o[2],v[0],v[1],v[2],color="g", length=L)
ax.quiver(o[0],o[1],o[2],w[0],w[1],w[2],color="b", length=L)
def qi(self, i):
return self.qs[i]
@property
def qis_range(self):
return self._qis_range
@qis_range.setter
def qis_range(self, *args):
self._qis_range = args
def plot_workspace(self):
""" TODO """
pass
class RigidBody2D(object):
"""
Defines a rigid body through a series of points that
make it up.
"""
def __init__(self,points):
self._points = points # Points
self.Hs = [eye(4),] # Transformation matrices
def restart(self):
self.Hs = [eye(4),]
@property
def points(self):
_points = []
H = self.H #
for p in self._points:
Q = Matrix([p[0],p[1],0,1]) # Homogeneous coordinates
_points.append(H*Q)
return _points
@property
def H(self):
_h = eye(4)
for _mth in self.Hs:
_h = _h*_mth
return _h
def rotate(self,angle):
"""
Rota el cuerpo rígido un ángulo determinado alrededor
del eje coordenado z.
"""
R = htmrot(angle, axis="z") # Aplicando rotación
self.Hs.append(R)
def move(self,q):
"""
Traslada el cuerpo rígido un vector q
"""
D = htmtra(q) # Aplicando traslación
self.Hs.append(D)
def scale(self,sf):
"""
Escala el cuerpo rígido
"""
# ~ S = self.scale_matrix(sf) # Aplicando escalado
# ~ self.Hs.append(S)
pass # nothing to do here
def scale_matrix(self,sf):
M = Matrix([[sf,0,0,0],
[0,sf,0,0],
[0,0,sf,0],
[0,0,0,sf]])
return M
def draw(self,color="r",kaxis=None):
"""
Dibuja el cuerpo rígido en sus estatus actual
"""
X,Y = [],[]
cx,cy = self.get_centroid()
for p in self.points:
X.append(p[0])
Y.append(p[1])
plt.fill(X,Y,color,alpha=0.8)
plt.plot(cx,cy,"r.")
plt.axis('equal')
plt.grid(ls="--")
O = self.H[:3,3]
U = self.H[:3,0]
V = self.H[:3,1]
plt.quiver(float(O[0]), float(O[1]), float(U[0]), float(U[1]), color="r", zorder=1000, scale=kaxis)
plt.quiver(float(O[0]), float(O[1]), float(V[0]), float(V[1]), color="g", zorder=1001, scale=kaxis)
def get_centroid(self):
n = len(self.points)
sx,sy = 0,0
for point in self.points:
sx += point[0]
sy += point[1]
cx = sx/n
cy = sy/n
return cx,cy
def test_robot():
r = Robot((l1,0,0,t1), (l2,0,0,t2))
r.plot_diagram({t1:pi/2, t2:pi/2, l1:100, l2:100})
def test_rb2():
points = [(0,0),(3,0),(0,1)]
rb = RigidBody2D(points)
rb.draw("r")
rb.move([10,0,0])
rb.draw("g")
rb.rotate(pi/2)
rb.move([5,0,0])
rb.draw("b")
plt.show()
print(rb.Hs)
if __name__=="__main__":
print(30*"aaaaa")
| 25.884892 | 107 | 0.473041 |
ace05697158c20b18450f8167981ed4c9b2d8dc1 | 23,823 | py | Python | mesonbuild/minstall.py | hwti/meson | 9e5c881b06bfb79ee9ee40cdd8dca3a78f268a40 | [
"Apache-2.0"
] | 1 | 2021-09-14T00:19:25.000Z | 2021-09-14T00:19:25.000Z | mesonbuild/minstall.py | hwti/meson | 9e5c881b06bfb79ee9ee40cdd8dca3a78f268a40 | [
"Apache-2.0"
] | null | null | null | mesonbuild/minstall.py | hwti/meson | 9e5c881b06bfb79ee9ee40cdd8dca3a78f268a40 | [
"Apache-2.0"
] | 1 | 2021-06-12T19:07:19.000Z | 2021-06-12T19:07:19.000Z | # Copyright 2013-2014 The Meson development team
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys, pickle, os, shutil, subprocess, errno
import argparse
import shlex
from glob import glob
from .scripts import depfixer
from .scripts import destdir_join
from .mesonlib import is_windows, Popen_safe
from .mtest import rebuild_all
try:
from __main__ import __file__ as main_file
except ImportError:
# Happens when running as meson.exe which is native Windows.
# This is only used for pkexec which is not, so this is fine.
main_file = None
symlink_warning = '''Warning: trying to copy a symlink that points to a file. This will copy the file,
but this will be changed in a future version of Meson to copy the symlink as is. Please update your
build definitions so that it will not break when the change happens.'''
selinux_updates = []
def add_arguments(parser):
parser.add_argument('-C', default='.', dest='wd',
help='directory to cd into before running')
parser.add_argument('--profile-self', action='store_true', dest='profile',
help=argparse.SUPPRESS)
parser.add_argument('--no-rebuild', default=False, action='store_true',
help='Do not rebuild before installing.')
parser.add_argument('--only-changed', default=False, action='store_true',
help='Only overwrite files that are older than the copied file.')
parser.add_argument('--quiet', default=False, action='store_true',
help='Do not print every file that was installed.')
class DirMaker:
def __init__(self, lf):
self.lf = lf
self.dirs = []
def makedirs(self, path, exist_ok=False):
dirname = os.path.normpath(path)
dirs = []
while dirname != os.path.dirname(dirname):
if not os.path.exists(dirname):
dirs.append(dirname)
dirname = os.path.dirname(dirname)
os.makedirs(path, exist_ok=exist_ok)
# store the directories in creation order, with the parent directory
# before the child directories. Future calls of makedir() will not
# create the parent directories, so the last element in the list is
# the last one to be created. That is the first one to be removed on
# __exit__
dirs.reverse()
self.dirs += dirs
def __enter__(self):
return self
def __exit__(self, exception_type, value, traceback):
self.dirs.reverse()
for d in self.dirs:
append_to_log(self.lf, d)
def is_executable(path, follow_symlinks=False):
'''Checks whether any of the "x" bits are set in the source file mode.'''
return bool(os.stat(path, follow_symlinks=follow_symlinks).st_mode & 0o111)
def append_to_log(lf, line):
lf.write(line)
if not line.endswith('\n'):
lf.write('\n')
lf.flush()
def set_chown(path, user=None, group=None, dir_fd=None, follow_symlinks=True):
# shutil.chown will call os.chown without passing all the parameters
# and particularly follow_symlinks, thus we replace it temporary
# with a lambda with all the parameters so that follow_symlinks will
# be actually passed properly.
# Not nice, but better than actually rewriting shutil.chown until
# this python bug is fixed: https://bugs.python.org/issue18108
real_os_chown = os.chown
try:
os.chown = lambda p, u, g: real_os_chown(p, u, g,
dir_fd=dir_fd,
follow_symlinks=follow_symlinks)
shutil.chown(path, user, group)
except Exception:
raise
finally:
os.chown = real_os_chown
def set_chmod(path, mode, dir_fd=None, follow_symlinks=True):
try:
os.chmod(path, mode, dir_fd=dir_fd, follow_symlinks=follow_symlinks)
except (NotImplementedError, OSError, SystemError):
if not os.path.islink(path):
os.chmod(path, mode, dir_fd=dir_fd)
def sanitize_permissions(path, umask):
if umask == 'preserve':
return
new_perms = 0o777 if is_executable(path, follow_symlinks=False) else 0o666
new_perms &= ~umask
try:
set_chmod(path, new_perms, follow_symlinks=False)
except PermissionError as e:
msg = '{!r}: Unable to set permissions {!r}: {}, ignoring...'
print(msg.format(path, new_perms, e.strerror))
def set_mode(path, mode, default_umask):
if mode is None or (mode.perms_s or mode.owner or mode.group) is None:
# Just sanitize permissions with the default umask
sanitize_permissions(path, default_umask)
return
# No chown() on Windows, and must set one of owner/group
if not is_windows() and (mode.owner or mode.group) is not None:
try:
set_chown(path, mode.owner, mode.group, follow_symlinks=False)
except PermissionError as e:
msg = '{!r}: Unable to set owner {!r} and group {!r}: {}, ignoring...'
print(msg.format(path, mode.owner, mode.group, e.strerror))
except LookupError:
msg = '{!r}: Non-existent owner {!r} or group {!r}: ignoring...'
print(msg.format(path, mode.owner, mode.group))
except OSError as e:
if e.errno == errno.EINVAL:
msg = '{!r}: Non-existent numeric owner {!r} or group {!r}: ignoring...'
print(msg.format(path, mode.owner, mode.group))
else:
raise
# Must set permissions *after* setting owner/group otherwise the
# setuid/setgid bits will get wiped by chmod
# NOTE: On Windows you can set read/write perms; the rest are ignored
if mode.perms_s is not None:
try:
set_chmod(path, mode.perms, follow_symlinks=False)
except PermissionError as e:
msg = '{!r}: Unable to set permissions {!r}: {}, ignoring...'
print(msg.format(path, mode.perms_s, e.strerror))
else:
sanitize_permissions(path, default_umask)
def restore_selinux_contexts():
'''
Restores the SELinux context for files in @selinux_updates
If $DESTDIR is set, do not warn if the call fails.
'''
try:
subprocess.check_call(['selinuxenabled'])
except (FileNotFoundError, NotADirectoryError, PermissionError, subprocess.CalledProcessError):
# If we don't have selinux or selinuxenabled returned 1, failure
# is ignored quietly.
return
if not shutil.which('restorecon'):
# If we don't have restorecon, failure is ignored quietly.
return
with subprocess.Popen(['restorecon', '-F', '-f-', '-0'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:
out, err = proc.communicate(input=b'\0'.join(os.fsencode(f) for f in selinux_updates) + b'\0')
if proc.returncode != 0 and not os.environ.get('DESTDIR'):
print('Failed to restore SELinux context of installed files...',
'Standard output:', out.decode(),
'Standard error:', err.decode(), sep='\n')
def get_destdir_path(d, path):
if os.path.isabs(path):
output = destdir_join(d.destdir, path)
else:
output = os.path.join(d.fullprefix, path)
return output
def check_for_stampfile(fname):
'''Some languages e.g. Rust have output files
whose names are not known at configure time.
Check if this is the case and return the real
file instead.'''
if fname.endswith('.so') or fname.endswith('.dll'):
if os.stat(fname).st_size == 0:
(base, suffix) = os.path.splitext(fname)
files = glob(base + '-*' + suffix)
if len(files) > 1:
print("Stale dynamic library files in build dir. Can't install.")
sys.exit(1)
if len(files) == 1:
return files[0]
elif fname.endswith('.a') or fname.endswith('.lib'):
if os.stat(fname).st_size == 0:
(base, suffix) = os.path.splitext(fname)
files = glob(base + '-*' + '.rlib')
if len(files) > 1:
print("Stale static library files in build dir. Can't install.")
sys.exit(1)
if len(files) == 1:
return files[0]
return fname
class Installer:
def __init__(self, options, lf):
self.did_install_something = False
self.options = options
self.lf = lf
self.preserved_file_count = 0
def log(self, msg):
if not self.options.quiet:
print(msg)
def should_preserve_existing_file(self, from_file, to_file):
if not self.options.only_changed:
return False
# Always replace danging symlinks
if os.path.islink(from_file) and not os.path.isfile(from_file):
return False
from_time = os.stat(from_file).st_mtime
to_time = os.stat(to_file).st_mtime
return from_time <= to_time
def do_copyfile(self, from_file, to_file, makedirs=None):
outdir = os.path.split(to_file)[0]
if not os.path.isfile(from_file) and not os.path.islink(from_file):
raise RuntimeError('Tried to install something that isn\'t a file:'
'{!r}'.format(from_file))
# copyfile fails if the target file already exists, so remove it to
# allow overwriting a previous install. If the target is not a file, we
# want to give a readable error.
if os.path.exists(to_file):
if not os.path.isfile(to_file):
raise RuntimeError('Destination {!r} already exists and is not '
'a file'.format(to_file))
if self.should_preserve_existing_file(from_file, to_file):
append_to_log(self.lf, '# Preserving old file {}\n'.format(to_file))
self.preserved_file_count += 1
return False
os.remove(to_file)
elif makedirs:
# Unpack tuple
dirmaker, outdir = makedirs
# Create dirs if needed
dirmaker.makedirs(outdir, exist_ok=True)
self.log('Installing {} to {}'.format(from_file, outdir))
if os.path.islink(from_file):
if not os.path.exists(from_file):
# Dangling symlink. Replicate as is.
shutil.copy(from_file, outdir, follow_symlinks=False)
else:
# Remove this entire branch when changing the behaviour to duplicate
# symlinks rather than copying what they point to.
print(symlink_warning)
shutil.copyfile(from_file, to_file)
shutil.copystat(from_file, to_file)
else:
shutil.copyfile(from_file, to_file)
shutil.copystat(from_file, to_file)
selinux_updates.append(to_file)
append_to_log(self.lf, to_file)
return True
def do_copydir(self, data, src_dir, dst_dir, exclude, install_mode):
'''
Copies the contents of directory @src_dir into @dst_dir.
For directory
/foo/
bar/
excluded
foobar
file
do_copydir(..., '/foo', '/dst/dir', {'bar/excluded'}) creates
/dst/
dir/
bar/
foobar
file
Args:
src_dir: str, absolute path to the source directory
dst_dir: str, absolute path to the destination directory
exclude: (set(str), set(str)), tuple of (exclude_files, exclude_dirs),
each element of the set is a path relative to src_dir.
'''
if not os.path.isabs(src_dir):
raise ValueError('src_dir must be absolute, got {}'.format(src_dir))
if not os.path.isabs(dst_dir):
raise ValueError('dst_dir must be absolute, got {}'.format(dst_dir))
if exclude is not None:
exclude_files, exclude_dirs = exclude
else:
exclude_files = exclude_dirs = set()
for root, dirs, files in os.walk(src_dir):
assert os.path.isabs(root)
for d in dirs[:]:
abs_src = os.path.join(root, d)
filepart = os.path.relpath(abs_src, start=src_dir)
abs_dst = os.path.join(dst_dir, filepart)
# Remove these so they aren't visited by os.walk at all.
if filepart in exclude_dirs:
dirs.remove(d)
continue
if os.path.isdir(abs_dst):
continue
if os.path.exists(abs_dst):
print('Tried to copy directory {} but a file of that name already exists.'.format(abs_dst))
sys.exit(1)
data.dirmaker.makedirs(abs_dst)
shutil.copystat(abs_src, abs_dst)
sanitize_permissions(abs_dst, data.install_umask)
for f in files:
abs_src = os.path.join(root, f)
filepart = os.path.relpath(abs_src, start=src_dir)
if filepart in exclude_files:
continue
abs_dst = os.path.join(dst_dir, filepart)
if os.path.isdir(abs_dst):
print('Tried to copy file {} but a directory of that name already exists.'.format(abs_dst))
sys.exit(1)
parent_dir = os.path.dirname(abs_dst)
if not os.path.isdir(parent_dir):
os.mkdir(parent_dir)
shutil.copystat(os.path.dirname(abs_src), parent_dir)
# FIXME: what about symlinks?
self.do_copyfile(abs_src, abs_dst)
set_mode(abs_dst, install_mode, data.install_umask)
def do_install(self, datafilename):
with open(datafilename, 'rb') as ifile:
d = pickle.load(ifile)
d.destdir = os.environ.get('DESTDIR', '')
d.fullprefix = destdir_join(d.destdir, d.prefix)
if d.install_umask != 'preserve':
os.umask(d.install_umask)
self.did_install_something = False
try:
d.dirmaker = DirMaker(self.lf)
with d.dirmaker:
self.install_subdirs(d) # Must be first, because it needs to delete the old subtree.
self.install_targets(d)
self.install_headers(d)
self.install_man(d)
self.install_data(d)
restore_selinux_contexts()
self.run_install_script(d)
if not self.did_install_something:
self.log('Nothing to install.')
if not self.options.quiet and self.preserved_file_count > 0:
self.log('Preserved {} unchanged files, see {} for the full list'
.format(self.preserved_file_count, os.path.normpath(self.lf.name)))
except PermissionError:
if shutil.which('pkexec') is not None and 'PKEXEC_UID' not in os.environ:
print('Installation failed due to insufficient permissions.')
print('Attempting to use polkit to gain elevated privileges...')
os.execlp('pkexec', 'pkexec', sys.executable, main_file, *sys.argv[1:],
'-C', os.getcwd())
else:
raise
def install_subdirs(self, d):
for (src_dir, dst_dir, mode, exclude) in d.install_subdirs:
self.did_install_something = True
full_dst_dir = get_destdir_path(d, dst_dir)
self.log('Installing subdir {} to {}'.format(src_dir, full_dst_dir))
d.dirmaker.makedirs(full_dst_dir, exist_ok=True)
self.do_copydir(d, src_dir, full_dst_dir, exclude, mode)
def install_data(self, d):
for i in d.data:
fullfilename = i[0]
outfilename = get_destdir_path(d, i[1])
mode = i[2]
outdir = os.path.dirname(outfilename)
if self.do_copyfile(fullfilename, outfilename, makedirs=(d.dirmaker, outdir)):
self.did_install_something = True
set_mode(outfilename, mode, d.install_umask)
def install_man(self, d):
for m in d.man:
full_source_filename = m[0]
outfilename = get_destdir_path(d, m[1])
outdir = os.path.dirname(outfilename)
install_mode = m[2]
if self.do_copyfile(full_source_filename, outfilename, makedirs=(d.dirmaker, outdir)):
self.did_install_something = True
set_mode(outfilename, install_mode, d.install_umask)
def install_headers(self, d):
for t in d.headers:
fullfilename = t[0]
fname = os.path.basename(fullfilename)
outdir = get_destdir_path(d, t[1])
outfilename = os.path.join(outdir, fname)
install_mode = t[2]
if self.do_copyfile(fullfilename, outfilename, makedirs=(d.dirmaker, outdir)):
self.did_install_something = True
set_mode(outfilename, install_mode, d.install_umask)
def run_install_script(self, d):
env = {'MESON_SOURCE_ROOT': d.source_dir,
'MESON_BUILD_ROOT': d.build_dir,
'MESON_INSTALL_PREFIX': d.prefix,
'MESON_INSTALL_DESTDIR_PREFIX': d.fullprefix,
'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in d.mesonintrospect]),
}
if self.options.quiet:
env['MESON_INSTALL_QUIET'] = '1'
child_env = os.environ.copy()
child_env.update(env)
for i in d.install_scripts:
self.did_install_something = True # Custom script must report itself if it does nothing.
script = i['exe']
args = i['args']
name = ' '.join(script + args)
self.log('Running custom install script {!r}'.format(name))
try:
rc = subprocess.call(script + args, env=child_env)
if rc != 0:
sys.exit(rc)
except OSError:
print('Failed to run install script {!r}'.format(name))
sys.exit(1)
def install_targets(self, d):
for t in d.targets:
if not os.path.exists(t.fname):
# For example, import libraries of shared modules are optional
if t.optional:
self.log('File {!r} not found, skipping'.format(t.fname))
continue
else:
raise RuntimeError('File {!r} could not be found'.format(t.fname))
file_copied = False # not set when a directory is copied
fname = check_for_stampfile(t.fname)
outdir = get_destdir_path(d, t.outdir)
outname = os.path.join(outdir, os.path.basename(fname))
final_path = os.path.join(d.prefix, t.outdir, os.path.basename(fname))
aliases = t.aliases
should_strip = t.strip
install_rpath = t.install_rpath
install_name_mappings = t.install_name_mappings
install_mode = t.install_mode
if not os.path.exists(fname):
raise RuntimeError('File {!r} could not be found'.format(fname))
elif os.path.isfile(fname):
file_copied = self.do_copyfile(fname, outname, makedirs=(d.dirmaker, outdir))
set_mode(outname, install_mode, d.install_umask)
if should_strip and d.strip_bin is not None:
if fname.endswith('.jar'):
self.log('Not stripping jar target:', os.path.basename(fname))
continue
self.log('Stripping target {!r} using {}.'.format(fname, d.strip_bin[0]))
ps, stdo, stde = Popen_safe(d.strip_bin + [outname])
if ps.returncode != 0:
print('Could not strip file.\n')
print('Stdout:\n{}\n'.format(stdo))
print('Stderr:\n{}\n'.format(stde))
sys.exit(1)
if fname.endswith('.js'):
# Emscripten outputs js files and optionally a wasm file.
# If one was generated, install it as well.
wasm_source = os.path.splitext(fname)[0] + '.wasm'
if os.path.exists(wasm_source):
wasm_output = os.path.splitext(outname)[0] + '.wasm'
file_copied = self.do_copyfile(wasm_source, wasm_output)
elif os.path.isdir(fname):
fname = os.path.join(d.build_dir, fname.rstrip('/'))
outname = os.path.join(outdir, os.path.basename(fname))
d.dirmaker.makedirs(outdir, exist_ok=True)
self.do_copydir(d, fname, outname, None, install_mode)
else:
raise RuntimeError('Unknown file type for {!r}'.format(fname))
printed_symlink_error = False
for alias, to in aliases.items():
try:
symlinkfilename = os.path.join(outdir, alias)
try:
os.remove(symlinkfilename)
except FileNotFoundError:
pass
os.symlink(to, symlinkfilename)
append_to_log(self.lf, symlinkfilename)
except (NotImplementedError, OSError):
if not printed_symlink_error:
print("Symlink creation does not work on this platform. "
"Skipping all symlinking.")
printed_symlink_error = True
if file_copied:
self.did_install_something = True
try:
depfixer.fix_rpath(outname, install_rpath, final_path,
install_name_mappings, verbose=False)
except SystemExit as e:
if isinstance(e.code, int) and e.code == 0:
pass
else:
raise
def run(opts):
datafilename = 'meson-private/install.dat'
private_dir = os.path.dirname(datafilename)
log_dir = os.path.join(private_dir, '../meson-logs')
if not os.path.exists(os.path.join(opts.wd, datafilename)):
sys.exit('Install data not found. Run this command in build directory root.')
if not opts.no_rebuild:
if not rebuild_all(opts.wd):
sys.exit(-1)
os.chdir(opts.wd)
with open(os.path.join(log_dir, 'install-log.txt'), 'w') as lf:
installer = Installer(opts, lf)
append_to_log(lf, '# List of files installed by Meson')
append_to_log(lf, '# Does not contain files installed by custom scripts.')
if opts.profile:
import cProfile as profile
fname = os.path.join(private_dir, 'profile-installer.log')
profile.runctx('installer.do_install(datafilename)', globals(), locals(), filename=fname)
else:
installer.do_install(datafilename)
return 0
| 44.116667 | 111 | 0.585401 |
ace056a4cd5b89159f32e9a90a6ce123230eec4c | 782 | py | Python | orders/migrations/0003_auto_20211001_1216.py | MamvotaTake/Django-Application | 81fbb01d6cd5cc4a91f6ba68c21f2a1e1d21a37e | [
"MIT"
] | null | null | null | orders/migrations/0003_auto_20211001_1216.py | MamvotaTake/Django-Application | 81fbb01d6cd5cc4a91f6ba68c21f2a1e1d21a37e | [
"MIT"
] | null | null | null | orders/migrations/0003_auto_20211001_1216.py | MamvotaTake/Django-Application | 81fbb01d6cd5cc4a91f6ba68c21f2a1e1d21a37e | [
"MIT"
] | null | null | null | # Generated by Django 3.1 on 2021-10-01 05:16
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('store', '0002_variation'),
('orders', '0002_remove_order_country'),
]
operations = [
migrations.RemoveField(
model_name='orderproduct',
name='color',
),
migrations.RemoveField(
model_name='orderproduct',
name='size',
),
migrations.RemoveField(
model_name='orderproduct',
name='variation',
),
migrations.AddField(
model_name='orderproduct',
name='variations',
field=models.ManyToManyField(blank=True, to='store.Variation'),
),
]
| 24.4375 | 75 | 0.557545 |
ace05704a69587ceec57a8389ff830a72eb9ff08 | 3,111 | py | Python | testing/scripts/content_shell_crash_test.py | lyapple2008/webrtc_simplify | c4f9bdc72d8e2648c4f4b1934d22ae94a793b553 | [
"BSD-3-Clause"
] | 2 | 2019-08-06T16:33:09.000Z | 2020-05-01T09:23:18.000Z | testing/scripts/content_shell_crash_test.py | lyapple2008/webrtc_simplify | c4f9bdc72d8e2648c4f4b1934d22ae94a793b553 | [
"BSD-3-Clause"
] | null | null | null | testing/scripts/content_shell_crash_test.py | lyapple2008/webrtc_simplify | c4f9bdc72d8e2648c4f4b1934d22ae94a793b553 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import argparse
import json
import os
import sys
import common
# Add src/testing/ into sys.path for importing xvfb.
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
import xvfb
# Unfortunately we need to copy these variables from ../test_env.py.
# Importing it and using its get_sandbox_env breaks test runs on Linux
# (it seems to unset DISPLAY).
CHROME_SANDBOX_ENV = 'CHROME_DEVEL_SANDBOX'
CHROME_SANDBOX_PATH = '/opt/chromium/chrome_sandbox'
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument(
'--isolated-script-test-output', type=str,
required=True)
parser.add_argument(
'--isolated-script-test-chartjson-output', type=str,
required=False)
parser.add_argument(
'--isolated-script-test-perf-output', type=str,
required=False)
parser.add_argument(
'--isolated-script-test-filter', type=str,
required=False)
args = parser.parse_args(argv)
env = os.environ.copy()
# Assume we want to set up the sandbox environment variables all the
# time; doing so is harmless on non-Linux platforms and is needed
# all the time on Linux.
env[CHROME_SANDBOX_ENV] = CHROME_SANDBOX_PATH
additional_args = []
if sys.platform == 'win32':
exe = os.path.join('.', 'content_shell.exe')
elif sys.platform == 'darwin':
exe = os.path.join('.', 'Content Shell.app', 'Contents', 'MacOS',
'Content Shell')
# The Content Shell binary does not directly link against
# the Content Shell Framework (it is loaded at runtime). Ensure that
# symbols are dumped for the Framework too.
additional_args = [
'--additional-binary',
os.path.join('.', 'Content Shell.app', 'Contents', 'Frameworks',
'Content Shell Framework.framework', 'Versions',
'Current', 'Content Shell Framework')
]
else:
exe = os.path.join('.', 'content_shell')
with common.temporary_file() as tempfile_path:
env['CHROME_HEADLESS'] = '1'
rc = xvfb.run_executable([
sys.executable,
os.path.join(common.SRC_DIR, 'content', 'shell', 'tools',
'breakpad_integration_test.py'),
'--verbose',
'--build-dir', '.',
'--binary', exe,
'--json', tempfile_path
] + additional_args, env)
with open(tempfile_path) as f:
failures = json.load(f)
with open(args.isolated_script_test_output, 'w') as fp:
json.dump({
'valid': True,
'failures': failures,
}, fp)
return rc
def main_compile_targets(args):
json.dump(['content_shell_crash_test'], args.output)
if __name__ == '__main__':
# Conform minimally to the protocol defined by ScriptTest.
if 'compile_targets' in sys.argv:
funcs = {
'run': None,
'compile_targets': main_compile_targets,
}
sys.exit(common.run_script(sys.argv[1:], funcs))
sys.exit(main(sys.argv[1:]))
| 29.913462 | 72 | 0.659274 |
ace05706d712f020e8225d54ffe77a679afc9df2 | 2,262 | py | Python | azure-servicefabric/azure/servicefabric/models/replica_health_state_chunk.py | Christina-Kang/azure-sdk-for-python | bbf982eb06aab04b8151f69f1d230b7f5fb96ebf | [
"MIT"
] | 1 | 2022-03-30T22:39:15.000Z | 2022-03-30T22:39:15.000Z | azure-servicefabric/azure/servicefabric/models/replica_health_state_chunk.py | Christina-Kang/azure-sdk-for-python | bbf982eb06aab04b8151f69f1d230b7f5fb96ebf | [
"MIT"
] | 54 | 2016-03-25T17:25:01.000Z | 2018-10-22T17:27:54.000Z | azure-servicefabric/azure/servicefabric/models/replica_health_state_chunk.py | Christina-Kang/azure-sdk-for-python | bbf982eb06aab04b8151f69f1d230b7f5fb96ebf | [
"MIT"
] | 2 | 2017-01-20T18:25:46.000Z | 2017-05-12T21:31:47.000Z | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from .entity_health_state_chunk import EntityHealthStateChunk
class ReplicaHealthStateChunk(EntityHealthStateChunk):
"""Represents the health state chunk of a stateful service replica or a
stateless service instance.
The replica health state contains the replica ID and its aggregated health
state.
.
:param health_state: The health state of a Service Fabric entity such as
Cluster, Node, Application, Service, Partition, Replica etc. Possible
values include: 'Invalid', 'Ok', 'Warning', 'Error', 'Unknown'
:type health_state: str or ~azure.servicefabric.models.HealthState
:param replica_or_instance_id: Id of a stateful service replica or a
stateless service instance. This id is used in the queries that apply to
both stateful and stateless services. It is used by Service Fabric to
uniquely identify a replica of a partition of a stateful service or an
instance of a stateless service partition. It is unique within a partition
and does not change for the lifetime of the replica or the instance. If a
stateful replica gets dropped and another replica gets created on the same
node for the same partition, it will get a different value for the id. If
a stateless instance is failed over on the same or different node it will
get a different value for the id.
:type replica_or_instance_id: str
"""
_attribute_map = {
'health_state': {'key': 'HealthState', 'type': 'str'},
'replica_or_instance_id': {'key': 'ReplicaOrInstanceId', 'type': 'str'},
}
def __init__(self, health_state=None, replica_or_instance_id=None):
super(ReplicaHealthStateChunk, self).__init__(health_state=health_state)
self.replica_or_instance_id = replica_or_instance_id
| 48.12766 | 80 | 0.69275 |
ace057b7cb72676c15d205b0b3c7f776f7b5bacc | 160 | py | Python | server/tree.py | cbonoz/mit2020 | 175d9711fdb92b4f25f92a969311b849ec6d6967 | [
"MIT"
] | null | null | null | server/tree.py | cbonoz/mit2020 | 175d9711fdb92b4f25f92a969311b849ec6d6967 | [
"MIT"
] | 4 | 2020-04-20T04:25:37.000Z | 2022-02-27T00:50:20.000Z | server/tree.py | cbonoz/mit2020 | 175d9711fdb92b4f25f92a969311b849ec6d6967 | [
"MIT"
] | 2 | 2020-07-21T16:42:03.000Z | 2021-05-02T14:12:48.000Z | import spacy
from spacy import displacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("I want a smart contract named Ocean.")
displacy.serve(doc, style="dep")
| 20 | 49 | 0.74375 |
ace058491c402e14be502ba56638a91666dffe6f | 300 | py | Python | core/filters.py | alyonakurtse/BD_Student | 32db5e81c6beb06e3fcc3ff866e25b1fa30495a2 | [
"MIT"
] | null | null | null | core/filters.py | alyonakurtse/BD_Student | 32db5e81c6beb06e3fcc3ff866e25b1fa30495a2 | [
"MIT"
] | 13 | 2022-03-12T10:16:09.000Z | 2022-03-20T15:26:59.000Z | core/filters.py | alyonakurtse/BD_Student | 32db5e81c6beb06e3fcc3ff866e25b1fa30495a2 | [
"MIT"
] | null | null | null | import django_filters
import core.models
class StudentFilter(django_filters.FilterSet):
lastName = django_filters.Filter(lookup_expr='icontains', label='Фамилия')
group = django_filters.Filter(label='Группа')
class Meta:
model = core.models.Student
fields = '__all__'
| 23.076923 | 78 | 0.723333 |
ace058ded8a821d02bc71ac209ed422b093ded96 | 3,328 | py | Python | GradCAM.py | sain0722/GradCAM-CustomData | a7019aa2912a21d0268c7bf81bbb9d3695fd0203 | [
"MIT"
] | null | null | null | GradCAM.py | sain0722/GradCAM-CustomData | a7019aa2912a21d0268c7bf81bbb9d3695fd0203 | [
"MIT"
] | null | null | null | GradCAM.py | sain0722/GradCAM-CustomData | a7019aa2912a21d0268c7bf81bbb9d3695fd0203 | [
"MIT"
] | null | null | null | import torch
import numpy as np
import cv2
## Inference
class FeatureExtractor():
""" Class for extracting activations and
registering gradients from targetted intermediate layers """
def __init__(self, model, target_layers):
self.model = model
self.target_layers = target_layers
self.gradients = []
def save_gradient(self, grad):
self.gradients.append(grad)
def __call__(self, x):
outputs = []
self.gradients = []
for name, module in self.model._modules.items():
x = module(x)
if name in self.target_layers:
x.register_hook(self.save_gradient)
outputs += [x]
return outputs, x
class ModelOutputs():
""" Class for making a forward pass, and getting:
1. The network output.
2. Activations from intermeddiate targetted layers.
3. Gradients from intermeddiate targetted layers. """
def __init__(self, model, feature_module, target_layers):
self.model = model
self.feature_module = feature_module
self.feature_extractor = FeatureExtractor(self.feature_module, target_layers)
def get_gradients(self):
return self.feature_extractor.gradients
def __call__(self, x):
target_activations = []
for name, module in self.model._modules.items():
if module == self.feature_module:
target_activations, x = self.feature_extractor(x)
elif "avgpool" in name.lower():
x = module(x)
x = x.view(x.size(0), -1)
else:
x = module(x)
return target_activations, x
class GradCam:
def __init__(self, model, feature_module, target_layer_names, use_cuda=True):
self.model = model
self.feature_module = feature_module
self.model.eval()
self.cuda = use_cuda
if self.cuda:
self.model = model.cuda()
self.extractor = ModelOutputs(self.model, self.feature_module, target_layer_names)
def forward(self, input):
return self.model(input)
def __call__(self, input, index=None):
if self.cuda:
features, output = self.extractor(input.cuda())
else:
features, output = self.extractor(input)
if index == None:
index = np.argmax(output.cpu().data.numpy())
one_hot = np.zeros((1, output.size()[-1]), dtype=np.float32)
one_hot[0][index] = 1
one_hot = torch.from_numpy(one_hot).requires_grad_(True)
if self.cuda:
one_hot = torch.sum(one_hot.cuda() * output)
else:
one_hot = torch.sum(one_hot * output)
self.feature_module.zero_grad()
self.model.zero_grad()
one_hot.backward(retain_graph=True)
grads_val = self.extractor.get_gradients()[-1].cpu().data.numpy()
target = features[-1]
target = target.cpu().data.numpy()[0, :]
weights = np.mean(grads_val, axis=(2, 3))[0, :]
cam = np.zeros(target.shape[1:], dtype=np.float32)
for i, w in enumerate(weights):
cam += w * target[i, :, :]
cam = np.maximum(cam, 0)
cam = cv2.resize(cam, input.shape[2:])
cam = cam - np.min(cam)
cam = cam / np.max(cam)
return cam | 31.102804 | 90 | 0.598858 |
ace0593b606976c2caa0ab5b7fab13c28897f866 | 3,530 | py | Python | cogdl/models/nn/gat.py | zhangdan0602/cogdl | 35a338f29066e4b1a5d7f46217f09ebceaf13106 | [
"MIT"
] | 1,072 | 2019-08-02T05:46:21.000Z | 2022-03-31T07:51:53.000Z | cogdl/models/nn/gat.py | zhangdan0602/cogdl | 35a338f29066e4b1a5d7f46217f09ebceaf13106 | [
"MIT"
] | 96 | 2019-08-05T17:27:22.000Z | 2022-03-03T08:36:57.000Z | cogdl/models/nn/gat.py | zhangdan0602/cogdl | 35a338f29066e4b1a5d7f46217f09ebceaf13106 | [
"MIT"
] | 299 | 2019-08-08T07:33:10.000Z | 2022-03-31T09:30:07.000Z | import torch.nn as nn
import torch.nn.functional as F
from cogdl.layers import GATLayer
from .. import BaseModel, register_model
@register_model("gat")
class GAT(BaseModel):
r"""The GAT model from the `"Graph Attention Networks"
<https://arxiv.org/abs/1710.10903>`_ paper
Args:
num_features (int) : Number of input features.
num_classes (int) : Number of classes.
hidden_size (int) : The dimension of node representation.
dropout (float) : Dropout rate for model training.
alpha (float) : Coefficient of leaky_relu.
nheads (int) : Number of attention heads.
"""
@staticmethod
def add_args(parser):
"""Add model-specific arguments to the parser."""
# fmt: off
parser.add_argument("--num-features", type=int)
parser.add_argument("--num-layers", type=int, default=2)
parser.add_argument("--residual", action="store_true")
parser.add_argument("--num-classes", type=int)
parser.add_argument("--hidden-size", type=int, default=8)
parser.add_argument("--dropout", type=float, default=0.6)
parser.add_argument("--attn-drop", type=float, default=0.5)
parser.add_argument("--alpha", type=float, default=0.2)
parser.add_argument("--nhead", type=int, default=8)
parser.add_argument("--last-nhead", type=int, default=1)
parser.add_argument("--norm", type=str, default=None)
# fmt: on
@classmethod
def build_model_from_args(cls, args):
return cls(
args.num_features,
args.hidden_size,
args.num_classes,
args.num_layers,
args.dropout,
args.attn_drop,
args.alpha,
args.nhead,
args.residual,
args.last_nhead,
args.norm,
)
def __init__(
self,
in_feats,
hidden_size,
out_features,
num_layers,
dropout,
attn_drop,
alpha,
nhead,
residual,
last_nhead,
norm=None,
):
"""Sparse version of GAT."""
super(GAT, self).__init__()
self.dropout = dropout
self.attentions = nn.ModuleList()
self.attentions.append(
GATLayer(in_feats, hidden_size, nhead=nhead, attn_drop=attn_drop, alpha=alpha, residual=residual, norm=norm)
)
for i in range(num_layers - 2):
self.attentions.append(
GATLayer(
hidden_size * nhead,
hidden_size,
nhead=nhead,
attn_drop=attn_drop,
alpha=alpha,
residual=residual,
norm=norm,
)
)
self.attentions.append(
GATLayer(
hidden_size * nhead,
out_features,
attn_drop=attn_drop,
alpha=alpha,
nhead=last_nhead,
residual=False,
)
)
self.num_layers = num_layers
self.last_nhead = last_nhead
self.residual = residual
def forward(self, graph):
x = graph.x
for i, layer in enumerate(self.attentions):
x = F.dropout(x, p=self.dropout, training=self.training)
x = layer(graph, x)
if i != self.num_layers - 1:
x = F.elu(x)
return x
def predict(self, graph):
return self.forward(graph)
| 31.238938 | 120 | 0.550142 |
ace05985e15dd6f8e2abe76cd48a6c8438f15b6d | 572 | py | Python | modules/auth/routes.py | jirenmaa/twitter-clone | de211a7d73ef455f5759eba69cdceb4b51f5a9b0 | [
"MIT"
] | 5 | 2021-10-12T06:40:51.000Z | 2022-02-23T13:37:40.000Z | modules/auth/routes.py | jirenmaa/twitter-clone | de211a7d73ef455f5759eba69cdceb4b51f5a9b0 | [
"MIT"
] | null | null | null | modules/auth/routes.py | jirenmaa/twitter-clone | de211a7d73ef455f5759eba69cdceb4b51f5a9b0 | [
"MIT"
] | 1 | 2022-02-02T22:36:00.000Z | 2022-02-02T22:36:00.000Z | from django.urls import path
from modules.auth.index import (
auth_registration,
auth_activation,
auth_resetactivation,
auth_resetpassword,
auth_login,
auth_logout,
)
urlpatterns = [
path("activate/", auth_activation, name="activate"),
path("reset_activation/", auth_resetactivation, name="reset_activation"),
path("reset_password/", auth_resetpassword, name="reset_password"),
path("register/", auth_registration, name="register"),
path("login/", auth_login, name="login"),
path("logout/", auth_logout, name="logout"),
]
| 28.6 | 77 | 0.708042 |
ace05a5023d63c0663402b10920a6ca8aa5044d4 | 10,346 | py | Python | nemo/collections/nlp/modules/common/megatron/utils.py | gkucsko/NeMo | c1ae0a7744d9a0ac206f61b2883ce00c9b8339b9 | [
"Apache-2.0"
] | null | null | null | nemo/collections/nlp/modules/common/megatron/utils.py | gkucsko/NeMo | c1ae0a7744d9a0ac206f61b2883ce00c9b8339b9 | [
"Apache-2.0"
] | 1 | 2022-03-06T14:09:02.000Z | 2022-03-06T14:09:02.000Z | nemo/collections/nlp/modules/common/megatron/utils.py | gkucsko/NeMo | c1ae0a7744d9a0ac206f61b2883ce00c9b8339b9 | [
"Apache-2.0"
] | null | null | null | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utilities for models."""
import math
from typing import Dict, List, Union
import torch
import torch.nn.functional as F
try:
from apex.contrib.layer_norm.layer_norm import FastLayerNorm
from apex.normalization.fused_layer_norm import FusedLayerNorm # NOQA
from apex.transformer import parallel_state, tensor_parallel
from apex.transformer.enums import AttnMaskType
from apex.transformer.pipeline_parallel.schedules.common import listify_model
HAVE_APEX = True
except (ImportError, ModuleNotFoundError):
HAVE_APEX = False
class ApexGuardDefaults(object):
"""
This class can be used to replace missing classes when apex is missing.
"""
def __init__(self):
super().__init__()
def __getattr__(self, item):
return None
def parallel_lm_logits(input_, word_embeddings_weight, parallel_output, bias=None):
"""LM logits using word embedding weights."""
# Parallel logits.
input_parallel = tensor_parallel.copy_to_tensor_model_parallel_region(input_)
# Matrix multiply.
if bias is None:
logits_parallel = F.linear(input_parallel, word_embeddings_weight)
else:
logits_parallel = F.linear(input_parallel, word_embeddings_weight, bias)
# Gather if needed.
if parallel_output:
return logits_parallel
return tensor_parallel.gather_from_tensor_model_parallel_region(logits_parallel)
def init_method_normal(sigma):
"""Init method based on N(0, sigma)."""
def init_(tensor):
return torch.nn.init.normal_(tensor, mean=0.0, std=sigma)
return init_
def scaled_init_method_normal(sigma, num_layers):
"""Init method based on N(0, sigma/sqrt(2*num_layers)."""
std = sigma / math.sqrt(2.0 * num_layers)
def init_(tensor):
return torch.nn.init.normal_(tensor, mean=0.0, std=std)
return init_
def attention_mask_func(attention_scores, attention_mask):
attention_scores.masked_fill_(attention_mask, -10000.0)
return attention_scores
def get_linear_layer(rows, columns, init_method):
"""Simple linear layer with weight initialization."""
layer = torch.nn.Linear(rows, columns)
init_method(layer.weight)
with torch.no_grad():
layer.bias.zero_()
return layer
@torch.jit.script
def gelu_impl(x):
"""OpenAI's gelu implementation."""
return 0.5 * x * (1.0 + torch.tanh(0.7978845608028654 * x * (1.0 + 0.044715 * x * x)))
def openai_gelu(x):
return gelu_impl(x)
# This is actually Python equivalent of torch.nn.functional.gelu(), also with type hints for ONNX exporter
@torch.jit.script
def erf_gelu(x):
return x * 0.5 * (torch.erf(x / 1.41421).to(dtype=x.dtype) + torch.ones_like(x).to(dtype=x.dtype))
def average_losses_across_data_parallel_group(losses):
"""Reduce a tensor of losses across all GPUs."""
averaged_losses = torch.cat([loss.clone().detach().view(1) for loss in losses])
torch.distributed.all_reduce(averaged_losses, group=parallel_state.get_data_parallel_group())
averaged_losses = averaged_losses / torch.distributed.get_world_size(
group=parallel_state.get_data_parallel_group()
)
return averaged_losses
def get_ltor_masks_and_position_ids(data, eod_token, reset_position_ids, reset_attention_mask, eod_mask_loss):
"""Build masks and position id for left to right model."""
# Extract batch size and sequence length.
micro_batch_size, seq_length = data.size()
# Attention mask (lower triangular).
if reset_attention_mask:
att_mask_batch = micro_batch_size
else:
att_mask_batch = 1
attention_mask = torch.tril(torch.ones((att_mask_batch, seq_length, seq_length), device=data.device)).view(
att_mask_batch, 1, seq_length, seq_length
)
# Loss mask.
loss_mask = torch.ones(data.size(), dtype=torch.float, device=data.device)
if eod_mask_loss:
loss_mask[data == eod_token] = 0.0
# Position ids.
position_ids = torch.arange(seq_length, dtype=torch.long, device=data.device)
position_ids = position_ids.unsqueeze(0).repeat(micro_batch_size, 1)
# We need to clone as the ids will be modifed based on batch index.
if reset_position_ids:
position_ids = position_ids.clone()
if reset_position_ids or reset_attention_mask:
# Loop through the batches:
for b in range(micro_batch_size):
# Find indecies where EOD token is.
eod_index = position_ids[b, data[b] == eod_token]
# Detach indecies from positions if going to modify positions.
if reset_position_ids:
eod_index = eod_index.clone()
# Loop through EOD indicies:
prev_index = 0
for j in range(eod_index.size()[0]):
i = eod_index[j]
# Mask attention loss.
if reset_attention_mask:
attention_mask[b, 0, (i + 1) :, : (i + 1)] = 0
# Reset positions.
if reset_position_ids:
position_ids[b, (i + 1) :] -= i + 1 - prev_index
prev_index = i + 1
# Convert attention mask to binary:
attention_mask = attention_mask < 0.5
return attention_mask, loss_mask, position_ids
def attn_mask_postprocess(attn_mask):
# [b, 1, s, s]
# Attn_masks for enc-dec attn and dec attn is None when trying to get just the encoder hidden states.
if attn_mask is None:
return None
extended_attention_mask = attn_mask.unsqueeze(1)
return extended_attention_mask
def enc_dec_extended_attention_mask(attention_mask_list):
return [attn_mask_postprocess(attn_mask) for attn_mask in attention_mask_list]
def build_position_ids(token_ids):
# Create position ids
seq_length = token_ids.size(1)
position_ids = torch.arange(seq_length, dtype=torch.long, device=token_ids.device)
position_ids = position_ids.unsqueeze(0).expand_as(token_ids).clone()
return position_ids
def make_attention_mask_3d(source_mask, target_mask):
"""
Returns a 3-dimensional (3-D) attention mask
:param source_block: 2-D array
:param target_block: 2-D array
"""
mask = target_mask[:, None, :] * source_mask[:, :, None]
return mask
def make_inference_attention_mask_3d(source_block, target_block, pad_id):
"""
Returns a 3-dimensional (3-D) attention mask
:param source_block: 2-D array
:param target_block: 2-D array
"""
# mask = (target_block[:, None, :] != pad_id) * (source_block[:, :, None] != pad_id)
return make_attention_mask_3d(source_block != pad_id, target_block != pad_id)
def make_inference_history_mask_3d(block):
batch, length = block.shape
arange = torch.arange(length, device=block.device)
history_mask = (arange[None,] <= arange[:, None])[
None,
]
history_mask = history_mask.expand(batch, length, length)
return history_mask
def build_attention_mask_3d_padding(source_mask, target_mask):
"""
Returns a 3D joint attention mask for Megatron given two 2D masks
:param source_mask - True for non-masked, else masked [batch, src length]
:param target_mask - True for non-masked, else masked [batch, tgt length]
"""
mask = make_attention_mask_3d(source_mask, target_mask)
# invert mask for Megatron
return mask < 0.5
def build_attention_mask_3d_causal(source_mask, target_mask):
"""
Returns a 3D joint attention mask for Megatron given two 2D masks
:param source_mask - True for non-masked, else masked [batch, src length]
:param target_mask - True for non-masked, else masked [batch, tgt length]
"""
causal_mask = make_inference_history_mask_3d(target_mask)
mask = make_attention_mask_3d(source_mask, target_mask)
mask = mask * causal_mask
# invert mask for Megatron
return mask < 0.5
def build_attention_mask_3d(source_mask, target_mask, attn_mask_type):
"""
Returns a 3D attention mask for Megatron given two 2D masks
:param source_mask - < 0.5 for non-masked, else masked [batch, src length]
:param target_mask - < 0.5 for non-masked, else masked [batch, tgt length]
:param attn_mask_type - AttnMaskType enum
"""
if attn_mask_type == AttnMaskType.padding:
mask = build_attention_mask_3d_padding(source_mask, target_mask)
elif attn_mask_type == AttnMaskType.causal:
mask = build_attention_mask_3d_causal(source_mask, target_mask)
else:
raise ValueError(f"Unsupported attention mask attn_mask_type = {attn_mask_type}")
return mask
def get_params_for_weight_decay_optimization(
model: Union[torch.nn.Module, List[torch.nn.Module]],
) -> Dict[str, torch.nn.Parameter]:
"""Divide params into with-weight-decay and without-weight-decay groups.
Layernorms and biases will have no weight decay but the rest will.
"""
modules = listify_model(model)
weight_decay_params = {'params': []}
no_weight_decay_params = {'params': [], 'weight_decay': 0.0}
for module in modules:
for module_ in module.modules():
if isinstance(module_, (FusedLayerNorm, FastLayerNorm)):
no_weight_decay_params['params'].extend(
[p for p in list(module_._parameters.values()) if p is not None]
)
else:
weight_decay_params['params'].extend(
[p for n, p in list(module_._parameters.items()) if p is not None and n != 'bias']
)
no_weight_decay_params['params'].extend(
[p for n, p in list(module_._parameters.items()) if p is not None and n == 'bias']
)
return weight_decay_params, no_weight_decay_params
| 34.835017 | 111 | 0.692442 |
ace05a930508493bfd8d1912e4400ef5a5fbcb2a | 1,078 | py | Python | pyjugex_handler/util.py | FZJ-INM1-BDA/pyjugex-webwrapper | a8170c331c3bb469ee149ebe61dc107434ccabc7 | [
"Apache-2.0"
] | null | null | null | pyjugex_handler/util.py | FZJ-INM1-BDA/pyjugex-webwrapper | a8170c331c3bb469ee149ebe61dc107434ccabc7 | [
"Apache-2.0"
] | null | null | null | pyjugex_handler/util.py | FZJ-INM1-BDA/pyjugex-webwrapper | a8170c331c3bb469ee149ebe61dc107434ccabc7 | [
"Apache-2.0"
] | null | null | null | import requests
import nibabel as nib
import os
import re
import tempfile
def get_pmap(url, json=None):
'''
given url as either a string or obj, interpretes, and performs get/post request
returns resp
may raise HTTP exception
'''
if json is None:
resp = requests.get(url)
else:
resp = requests.post(url, json=json)
resp.raise_for_status()
return resp
def get_filename_from_resp(resp):
# determine the type of the file. look at the disposition header, use PMapURL as a fallback
content_disposition_header = resp.headers.get('content-disposition')
filename = re.search(r'filename=(.*?)$', content_disposition_header).group(1) if content_disposition_header is not None and re.search(r'filename=(.*?)$', content_disposition_header) is not None else resp.url
return filename
def read_byte_via_nib(content, gzip=False):
fp, fp_name = tempfile.mkstemp(suffix='.nii.gz' if gzip else '.nii')
os.write(fp, content)
nii = nib.load(fp_name)
os.close(fp)
return nii
def is_gzipped(filename):
return re.search(r"\.gz$", filename) is not None | 30.8 | 209 | 0.736549 |
ace05abc57d78c690f0c23de0675eaf11cbd6224 | 49,167 | py | Python | lifelines/utils/__init__.py | pzivich/lifelines | 221b291707b91a67a6a7961e78e5a3d1cbede651 | [
"MIT"
] | 1 | 2019-08-22T11:57:06.000Z | 2019-08-22T11:57:06.000Z | lifelines/utils/__init__.py | pzivich/lifelines | 221b291707b91a67a6a7961e78e5a3d1cbede651 | [
"MIT"
] | null | null | null | lifelines/utils/__init__.py | pzivich/lifelines | 221b291707b91a67a6a7961e78e5a3d1cbede651 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
from __future__ import print_function, division
import warnings
from datetime import datetime
import numpy as np
from numpy.linalg import solve
from scipy import stats
import pandas as pd
from pandas import to_datetime
# ipython autocomplete will pick these up, which are probably what users only need.
__all__ = [
'qth_survival_times',
'qth_survival_time',
'median_survival_times',
'survival_table_from_events',
'datetimes_to_durations',
'concordance_index',
'k_fold_cross_validation',
'to_long_format',
'add_covariate_to_timeline',
'covariates_from_event_matrix'
]
class StatError(Exception):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return repr(self.msg)
class ConvergenceWarning(RuntimeWarning):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return repr(self.msg)
def qth_survival_times(q, survival_functions, cdf=False):
"""
Parameters:
q: a float between 0 and 1.
survival_functions: a (n,d) dataframe or numpy array.
If dataframe, will return index values (actual times)
If numpy array, will return indices.
Returns:
v: if d==1, returns a float, np.inf if infinity.
if d > 1, an DataFrame containing the first times the value was crossed.
"""
q = pd.Series(q)
if not((q <= 1).all() and (0 <= q).all()):
raise ValueError('q must be between 0 and 1')
survival_functions = pd.DataFrame(survival_functions)
if survival_functions.shape[1] == 1 and q.shape == (1,):
return survival_functions.apply(lambda s: qth_survival_time(q[0], s, cdf=cdf)).iloc[0]
else:
# Typically, one would expect that the output should equal the "height" of q.
# An issue can arise if the Series q contains duplicate values. We handle this un-eligantly.
if q.duplicated().any():
return pd.DataFrame.from_items([
(_q, survival_functions.apply(lambda s: qth_survival_time(_q, s))) for i, _q in enumerate(q)
], orient='index', columns=survival_functions.columns)
else:
return pd.DataFrame({_q: survival_functions.apply(lambda s: qth_survival_time(_q, s)) for _q in q}).T
def qth_survival_time(q, survival_function, cdf=False):
"""
Expects a Pandas series, returns the time when the qth probability is reached.
"""
if cdf:
if survival_function.iloc[0] > q:
return np.inf
v = (survival_function <= q).idxmin(0)
else:
if survival_function.iloc[-1] > q:
return np.inf
v = (survival_function <= q).idxmax(0)
return v
def median_survival_times(density_or_survival_function, left_censorship=False):
return qth_survival_times(0.5, density_or_survival_function, cdf=left_censorship)
def group_survival_table_from_events(groups, durations, event_observed, birth_times=None, limit=-1):
"""
Joins multiple event series together into dataframes. A generalization of
`survival_table_from_events` to data with groups. Previously called `group_event_series` pre 0.2.3.
Parameters:
groups: a (n,) array of individuals' group ids.
durations: a (n,) array of durations of each individual
event_observed: a (n,) array of event observations, 1 if observed, 0 else.
birth_times: a (n,) array of numbers representing
when the subject was first observed. A subject's death event is then at [birth times + duration observed].
Normally set to all zeros, but can be positive or negative.
Returns:
- np.array of unique groups
- dataframe of removal count data at event_times for each group, column names are 'removed:<group name>'
- dataframe of observed count data at event_times for each group, column names are 'observed:<group name>'
- dataframe of censored count data at event_times for each group, column names are 'censored:<group name>'
Example:
#input
group_survival_table_from_events(waltonG, waltonT, np.ones_like(waltonT)) #data available in test_suite.py
#output
[
array(['control', 'miR-137'], dtype=object),
removed:control removed:miR-137
event_at
6 0 1
7 2 0
9 0 3
13 0 3
15 0 2
,
observed:control observed:miR-137
event_at
6 0 1
7 2 0
9 0 3
13 0 3
15 0 2
,
censored:control censored:miR-137
event_at
6 0 0
7 0 0
9 0 0
,
]
"""
n = np.max(groups.shape)
assert n == np.max(durations.shape) == np.max(event_observed.shape), "inputs must be of the same length."
if birth_times is None:
# Create some birth times
birth_times = np.zeros(np.max(durations.shape))
birth_times[:] = np.min(durations)
assert n == np.max(birth_times.shape), "inputs must be of the same length."
groups, durations, event_observed, birth_times = [pd.Series(np.asarray(data).reshape(n,)) for data in [groups, durations, event_observed, birth_times]]
unique_groups = groups.unique()
for i, group in enumerate(unique_groups):
ix = groups == group
T = durations[ix]
C = event_observed[ix]
B = birth_times[ix]
group_name = str(group)
columns = [event_name + ":" + group_name for event_name in ['removed', 'observed', 'censored', 'entrance', 'at_risk']]
if i == 0:
data = survival_table_from_events(T, C, B, columns=columns)
else:
data = data.join(survival_table_from_events(T, C, B, columns=columns), how='outer')
data = data.fillna(0)
# hmmm pandas its too bad I can't do data.loc[:limit] and leave out the if.
if int(limit) != -1:
data = data.loc[:limit]
return unique_groups, data.filter(like='removed:'), data.filter(like='observed:'), data.filter(like='censored:')
def survival_table_from_events(death_times, event_observed, birth_times=None,
columns=["removed", "observed", "censored", "entrance", "at_risk"],
weights=None,
collapse=False,
intervals=None):
"""
Parameters:
death_times: (n,) array of event times
event_observed: (n,) boolean array, 1 if observed event, 0 is censored event.
birth_times: a (n,) array of numbers representing
when the subject was first observed. A subject's death event is then at [birth times + duration observed].
If None (default), birth_times are set to be the first observation or 0, which ever is smaller.
columns: a 3-length array to call the, in order, removed individuals, observed deaths
and censorships.
weights: Default None, otherwise (n,1) array. Optional argument to use weights for individuals.
collapse: Default False. If True, collapses survival table into lifetable to show events in interval bins
intervals: Default None, otherwise a list/(n,1) array of interval edge measures. If left as None
while collapse=True, then Freedman-Diaconis rule for histogram bins will be used to determine intervals.
Returns:
Pandas DataFrame with index as the unique times or intervals in event_times. The columns named
'removed' refers to the number of individuals who were removed from the population
by the end of the period. The column 'observed' refers to the number of removed
individuals who were observed to have died (i.e. not censored.) The column
'censored' is defined as 'removed' - 'observed' (the number of individuals who
left the population due to event_observed)
Example:
Uncollapsed
removed observed censored entrance at_risk
event_at
0 0 0 0 11 11
6 1 1 0 0 11
7 2 2 0 0 10
9 3 3 0 0 8
13 3 3 0 0 5
15 2 2 0 0 2
Collapsed
removed observed censored at_risk
sum sum sum max
event_at
(0, 2] 34 33 1 312
(2, 4] 84 42 42 278
(4, 6] 64 17 47 194
(6, 8] 63 16 47 130
(8, 10] 35 12 23 67
(10, 12] 24 5 19 32
"""
removed, observed, censored, entrance, at_risk = columns
death_times = np.asarray(death_times)
if birth_times is None:
birth_times = min(0, death_times.min()) * np.ones(death_times.shape[0])
else:
birth_times = np.asarray(birth_times)
if np.any(birth_times > death_times):
raise ValueError('birth time must be less than time of death.')
if weights is None:
weights = 1
else:
if (weights.astype(int) != weights).any():
warnings.warn("""It looks like your weights are not integers, possibly prospenity scores then?
It's important to know that the naive variance estimates of the coefficients are biased. Instead use Monte Carlo to
estimate the variances. See paper "Variance estimation when using inverse probability of treatment weighting (IPTW) with survival analysis"
or "Adjusted Kaplan-Meier estimator and log-rank test with inverse probability of treatment weighting for survival data."
""", RuntimeWarning)
# deal with deaths and censorships
df = pd.DataFrame(death_times, columns=["event_at"])
df[removed] = weights
df[observed] = weights * np.asarray(event_observed)
death_table = df.groupby("event_at").sum()
death_table[censored] = (death_table[removed] - death_table[observed]).astype(int)
# deal with late births
births = pd.DataFrame(birth_times, columns=['event_at'])
births[entrance] = weights
births_table = births.groupby('event_at').sum()
event_table = death_table.join(births_table, how='outer', sort=True).fillna(0) # http://wesmckinney.com/blog/?p=414
event_table[at_risk] = event_table[entrance].cumsum() - event_table[removed].cumsum().shift(1).fillna(0)
# group by intervals
if collapse:
event_table = _group_event_table_by_intervals(event_table, intervals)
return event_table.astype(int)
def _group_event_table_by_intervals(event_table, intervals):
event_table = event_table.reset_index()
# use Freedman-Diaconis rule to determine bin size if user doesn't define intervals
if intervals is None:
event_max = event_table['event_at'].max()
# need interquartile range for bin width
q75, q25 = np.percentile(event_table['event_at'], [75, 25])
event_iqr = q75 - q25
bin_width = 2 * event_iqr * (len(event_table['event_at']) ** (-1 / 3))
intervals = np.arange(0, event_max + bin_width, bin_width)
return event_table.groupby(pd.cut(event_table['event_at'], intervals)).agg({'removed': ['sum'],
'observed': ['sum'],
'censored': ['sum'],
'at_risk': ['max']})
def survival_events_from_table(event_table, observed_deaths_col="observed", censored_col="censored"):
"""
This is the inverse of the function ``survival_table_from_events``.
Parameters
event_table: a pandas DataFrame with index as the durations (!!) and columns "observed" and "censored", referring to
the number of individuals that died and were censored at time t.
Returns
T: a np.array of durations of observation -- one element for each individual in the population.
C: a np.array of event observations -- one element for each individual in the population. 1 if observed, 0 else.
Ex: The survival table, as a pandas DataFrame:
observed censored
index
1 1 0
2 0 1
3 1 0
4 1 1
5 0 1
would return
T = np.array([ 1., 2., 3., 4., 4., 5.]),
C = np.array([ 1., 0., 1., 1., 0., 0.])
"""
columns = [observed_deaths_col, censored_col]
N = event_table[columns].sum().sum()
T = np.empty(N)
C = np.empty(N)
i = 0
for event_time, row in event_table.iterrows():
n = row[columns].sum()
T[i:i + n] = event_time
C[i:i + n] = np.r_[np.ones(row[columns[0]]), np.zeros(row[columns[1]])]
i += n
return T, C
def datetimes_to_durations(start_times, end_times, fill_date=datetime.today(), freq='D', dayfirst=False, na_values=None):
"""
This is a very flexible function for transforming arrays of start_times and end_times
to the proper format for lifelines: duration and event observation arrays.
Parameters:
start_times: an array, series or dataframe of start times. These can be strings, or datetimes.
end_times: an array, series or dataframe of end times. These can be strings, or datetimes.
These values can be None, or an empty string, which corresponds to censorship.
fill_date: the date to use if end_times is a None or empty string. This corresponds to last date
of observation. Anything after this date is also censored. Default: datetime.today()
freq: the units of time to use. See pandas 'freq'. Default 'D' for days.
day_first: convert assuming European-style dates, i.e. day/month/year.
na_values : list of values to recognize as NA/NaN. Ex: ['', 'NaT']
Returns:
T: a array of floats representing the durations with time units given by freq.
C: a boolean array of event observations: 1 if death observed, 0 else.
"""
fill_date = pd.to_datetime(fill_date)
freq_string = 'timedelta64[%s]' % freq
start_times = pd.Series(start_times).copy()
end_times = pd.Series(end_times).copy()
C = ~(pd.isnull(end_times).values | end_times.isin(na_values or [""]))
end_times[~C] = fill_date
start_times_ = to_datetime(start_times, dayfirst=dayfirst)
end_times_ = to_datetime(end_times, dayfirst=dayfirst, errors='coerce')
deaths_after_cutoff = end_times_ > fill_date
C[deaths_after_cutoff] = False
T = (end_times_ - start_times_).values.astype(freq_string).astype(float)
if (T < 0).sum():
warnings.warn("Warning: some values of start_times are after end_times")
return T, C.values
def l1_log_loss(event_times, predicted_event_times, event_observed=None):
"""
Calculates the l1 log-loss of predicted event times to true event times for *non-censored*
individuals only.
1/N \sum_{i} |log(t_i) - log(q_i)|
Parameters:
event_times: a (n,) array of observed survival times.
predicted_event_times: a (n,) array of predicted survival times.
event_observed: a (n,) array of censorship flags, 1 if observed,
0 if not. Default None assumes all observed.
Returns:
l1-log-loss: a scalar
"""
if event_observed is None:
event_observed = np.ones_like(event_times)
ix = event_observed.astype(bool)
return np.abs(np.log(event_times[ix]) - np.log(predicted_event_times[ix])).mean()
def l2_log_loss(event_times, predicted_event_times, event_observed=None):
"""
Calculates the l2 log-loss of predicted event times to true event times for *non-censored*
individuals only.
1/N \sum_{i} (log(t_i) - log(q_i))**2
Parameters:
event_times: a (n,) array of observed survival times.
predicted_event_times: a (n,) array of predicted survival times.
event_observed: a (n,) array of censorship flags, 1 if observed,
0 if not. Default None assumes all observed.
Returns:
l2-log-loss: a scalar
"""
if event_observed is None:
event_observed = np.ones_like(event_times)
ix = event_observed.astype(bool)
return np.power(np.log(event_times[ix]) - np.log(predicted_event_times[ix]), 2).mean()
def concordance_index(event_times, predicted_event_times, event_observed=None):
"""
Calculates the concordance index (C-index) between two series
of event times. The first is the real survival times from
the experimental data, and the other is the predicted survival
times from a model of some kind.
The concordance index is a value between 0 and 1 where,
0.5 is the expected result from random predictions,
1.0 is perfect concordance and,
0.0 is perfect anti-concordance (multiply predictions with -1 to get 1.0)
Score is usually 0.6-0.7 for survival models.
See:
Harrell FE, Lee KL, Mark DB. Multivariable prognostic models: issues in
developing models, evaluating assumptions and adequacy, and measuring and
reducing errors. Statistics in Medicine 1996;15(4):361-87.
Parameters:
event_times: a (n,) array of observed survival times.
predicted_event_times: a (n,) array of predicted survival times.
event_observed: a (n,) array of censorship flags, 1 if observed,
0 if not. Default None assumes all observed.
Returns:
c-index: a value between 0 and 1.
"""
event_times = np.array(event_times, dtype=float)
predicted_event_times = np.array(predicted_event_times, dtype=float)
# Allow for (n, 1) or (1, n) arrays
if event_times.ndim == 2 and (event_times.shape[0] == 1 or
event_times.shape[1] == 1):
# Flatten array
event_times = event_times.ravel()
# Allow for (n, 1) or (1, n) arrays
if (predicted_event_times.ndim == 2 and
(predicted_event_times.shape[0] == 1 or
predicted_event_times.shape[1] == 1)):
# Flatten array
predicted_event_times = predicted_event_times.ravel()
if event_times.shape != predicted_event_times.shape:
raise ValueError("Event times and predictions must have the same shape")
if event_times.ndim != 1:
raise ValueError("Event times can only be 1-dimensional: (n,)")
if event_observed is None:
event_observed = np.ones(event_times.shape[0], dtype=float)
else:
if event_observed.shape != event_times.shape:
raise ValueError("Observed events must be 1-dimensional of same length as event times")
event_observed = np.array(event_observed, dtype=float).ravel()
return _concordance_index(event_times,
predicted_event_times,
event_observed)
def coalesce(*args):
for arg in args:
if arg is not None:
return arg
return None
def inv_normal_cdf(p):
return stats.norm.ppf(p)
def k_fold_cross_validation(fitters, df, duration_col, event_col=None,
k=5, evaluation_measure=concordance_index,
predictor="predict_expectation", predictor_kwargs={},
fitter_kwargs={}):
"""
Perform cross validation on a dataset. If multiple models are provided,
all models will train on each of the k subsets.
fitter(s): one or several objects which possess a method:
fit(self, data, duration_col, event_col)
Note that the last two arguments will be given as keyword arguments,
and that event_col is optional. The objects must also have
the "predictor" method defined below.
df: a Pandas dataframe with necessary columns `duration_col` and `event_col`, plus
other covariates. `duration_col` refers to the lifetimes of the subjects. `event_col`
refers to whether the 'death' events was observed: 1 if observed, 0 else (censored).
duration_col: the column in dataframe that contains the subjects lifetimes.
event_col: the column in dataframe that contains the subject's death observation. If left
as None, assumes all individuals are non-censored.
k: the number of folds to perform. n/k data will be withheld for testing on.
evaluation_measure: a function that accepts either (event_times, predicted_event_times),
or (event_times, predicted_event_times, event_observed)
and returns something (could be anything).
Default: statistics.concordance_index: (C-index)
between two series of event times
predictor: a string that matches a prediction method on the fitter instances.
For example, "predict_expectation" or "predict_percentile".
Default is "predict_expectation"
The interface for the method is:
predict(self, data, **optional_kwargs)
fitter_kwargs: keyword args to pass into fitter.fit method
predictor_kwargs: keyword args to pass into predictor-method.
Returns:
(k,1) list of scores for each fold. The scores can be anything.
"""
# Make sure fitters is a list
try:
fitters = list(fitters)
except TypeError:
fitters = [fitters]
# Each fitter has its own scores
fitterscores = [[] for _ in fitters]
n, d = df.shape
df = df.copy()
if event_col is None:
event_col = 'E'
df[event_col] = 1.
df = df.reindex(np.random.permutation(df.index)).sort_values(event_col)
assignments = np.array((n // k + 1) * list(range(1, k + 1)))
assignments = assignments[:n]
testing_columns = df.columns.drop([duration_col, event_col])
for i in range(1, k + 1):
ix = assignments == i
training_data = df.loc[~ix]
testing_data = df.loc[ix]
T_actual = testing_data[duration_col].values
E_actual = testing_data[event_col].values
X_testing = testing_data[testing_columns]
for fitter, scores in zip(fitters, fitterscores):
# fit the fitter to the training data
fitter.fit(training_data, duration_col=duration_col,
event_col=event_col, **fitter_kwargs)
T_pred = getattr(fitter, predictor)(X_testing, **predictor_kwargs).values
try:
scores.append(evaluation_measure(T_actual, T_pred, E_actual))
except TypeError:
scores.append(evaluation_measure(T_actual, T_pred))
# If a single fitter was given as argument, return a single result
if len(fitters) == 1:
return fitterscores[0]
else:
return fitterscores
def normalize(X, mean=None, std=None):
'''
Normalize X. If mean OR std is None, normalizes
X to have mean 0 and std 1.
'''
if mean is None or std is None:
mean = X.mean(0)
std = X.std(0)
return (X - mean) / std
def unnormalize(X, mean, std):
'''
Reverse a normalization. Requires the original mean and
standard deviation of the data set.
'''
return X * std + mean
def epanechnikov_kernel(t, T, bandwidth=1.):
M = 0.75 * (1 - ((t - T) / bandwidth) ** 2)
M[abs((t - T)) >= bandwidth] = 0
return M
def significance_code(p):
if p < 0.001:
return '***'
elif p < 0.01:
return '**'
elif p < 0.05:
return '*'
elif p < 0.1:
return '.'
else:
return ' '
def ridge_regression(X, Y, c1=0.0, c2=0.0, offset=None):
"""
Also known as Tikhonov regularization. This solves the minimization problem:
min_{beta} ||(beta X - Y)||^2 + c1||beta||^2 + c2||beta - offset||^2
One can find more information here: http://en.wikipedia.org/wiki/Tikhonov_regularization
Parameters:
X: a (n,d) numpy array
Y: a (n,) numpy array
c1: a scalar
c2: a scalar
offset: a (d,) numpy array.
Returns:
beta_hat: the solution to the minimization problem.
V = (X*X^T + (c1+c2)I)^{-1} X^T
"""
n, d = X.shape
X = X.astype(float)
penalizer_matrix = (c1 + c2) * np.eye(d)
if offset is None:
offset = np.zeros((d,))
A = (np.dot(X.T, X) + penalizer_matrix)
b = (np.dot(X.T, Y) + c2 * offset)
# rather than explicitly computing the inverse, just solve the system of equations
return (solve(A, b), solve(A, X.T))
def _smart_search(minimizing_function, n, *args):
from scipy.optimize import fmin_powell
x = np.ones(n)
return fmin_powell(minimizing_function, x, args=args, disp=False)
def _additive_estimate(events, timeline, _additive_f, _additive_var, reverse):
"""
Called to compute the Kaplan Meier and Nelson-Aalen estimates.
"""
if reverse:
events = events.sort_index(ascending=False)
at_risk = events['entrance'].sum() - events['removed'].cumsum().shift(1).fillna(0)
deaths = events['observed']
estimate_ = np.cumsum(_additive_f(at_risk, deaths)).sort_index().shift(-1).fillna(0)
var_ = np.cumsum(_additive_var(at_risk, deaths)).sort_index().shift(-1).fillna(0)
else:
deaths = events['observed']
at_risk = events['at_risk']
estimate_ = np.cumsum(_additive_f(at_risk, deaths))
var_ = np.cumsum(_additive_var(at_risk, deaths))
timeline = sorted(timeline)
estimate_ = estimate_.reindex(timeline, method='pad').fillna(0)
var_ = var_.reindex(timeline, method='pad')
var_.index.name = 'timeline'
estimate_.index.name = 'timeline'
return estimate_, var_
def _preprocess_inputs(durations, event_observed, timeline, entry, weights):
"""
Cleans and confirms input to what lifelines expects downstream
"""
n = len(durations)
durations = np.asarray(durations).reshape((n,))
# set to all observed if event_observed is none
if event_observed is None:
event_observed = np.ones(n, dtype=int)
else:
event_observed = np.asarray(event_observed).reshape((n,)).copy().astype(int)
if entry is not None:
entry = np.asarray(entry).reshape((n,))
event_table = survival_table_from_events(durations, event_observed, entry, weights=weights)
if timeline is None:
timeline = event_table.index.values
else:
timeline = np.asarray(timeline)
return durations, event_observed, timeline.astype(float), entry, event_table
def _get_index(X):
if isinstance(X, pd.DataFrame):
index = list(X.index)
else:
# If it's not a dataframe, order is up to user
index = list(range(X.shape[0]))
return index
class _BTree(object):
"""A simple balanced binary order statistic tree to help compute the concordance.
When computing the concordance, we know all the values the tree will ever contain. That
condition simplifies this tree a lot. It means that instead of crazy AVL/red-black shenanigans
we can simply do the following:
- Store the final tree in flattened form in an array (so node i's children are 2i+1, 2i+2)
- Additionally, store the current size of each subtree in another array with the same indices
- To insert a value, just find its index, increment the size of the subtree at that index and
propagate
- To get the rank of an element, you add up a bunch of subtree counts
"""
def __init__(self, values):
"""
Parameters:
values: List of sorted (ascending), unique values that will be inserted.
"""
self._tree = self._treeify(values)
self._counts = np.zeros_like(self._tree, dtype=int)
@staticmethod
def _treeify(values):
"""Convert the np.ndarray `values` into a complete balanced tree.
Assumes `values` is sorted ascending. Returns a list `t` of the same length in which t[i] >
t[2i+1] and t[i] < t[2i+2] for all i."""
if len(values) == 1: # this case causes problems later
return values
tree = np.empty_like(values)
# Tree indices work as follows:
# 0 is the root
# 2n+1 is the left child of n
# 2n+2 is the right child of n
# So we now rearrange `values` into that format...
# The first step is to remove the bottom row of leaves, which might not be exactly full
last_full_row = int(np.log2(len(values) + 1) - 1)
len_ragged_row = len(values) - (2 ** (last_full_row + 1) - 1)
if len_ragged_row > 0:
bottom_row_ix = np.s_[:2 * len_ragged_row:2]
tree[-len_ragged_row:] = values[bottom_row_ix]
values = np.delete(values, bottom_row_ix)
# Now `values` is length 2**n - 1, so can be packed efficiently into a tree
# Last row of nodes is indices 0, 2, ..., 2**n - 2
# Second-last row is indices 1, 5, ..., 2**n - 3
# nth-last row is indices (2**n - 1)::(2**(n+1))
values_start = 0
values_space = 2
values_len = 2 ** last_full_row
while values_start < len(values):
tree[values_len - 1:2 * values_len - 1] = values[values_start::values_space]
values_start += int(values_space / 2)
values_space *= 2
values_len = int(values_len / 2)
return tree
def insert(self, value):
"""Insert an occurrence of `value` into the btree."""
i = 0
n = len(self._tree)
while i < n:
cur = self._tree[i]
self._counts[i] += 1
if value < cur:
i = 2 * i + 1
elif value > cur:
i = 2 * i + 2
else:
return
raise ValueError("Value %s not contained in tree."
"Also, the counts are now messed up." % value)
def __len__(self):
return self._counts[0]
def rank(self, value):
"""Returns the rank and count of the value in the btree."""
i = 0
n = len(self._tree)
rank = 0
count = 0
while i < n:
cur = self._tree[i]
if value < cur:
i = 2 * i + 1
continue
elif value > cur:
rank += self._counts[i]
# subtract off the right tree if exists
nexti = 2 * i + 2
if nexti < n:
rank -= self._counts[nexti]
i = nexti
continue
else:
return (rank, count)
else: # value == cur
count = self._counts[i]
lefti = 2 * i + 1
if lefti < n:
nleft = self._counts[lefti]
count -= nleft
rank += nleft
righti = lefti + 1
if righti < n:
count -= self._counts[righti]
return (rank, count)
return (rank, count)
def _concordance_index(event_times, predicted_event_times, event_observed):
"""Find the concordance index in n * log(n) time.
Assumes the data has been verified by lifelines.utils.concordance_index first.
"""
# Here's how this works.
#
# It would be pretty easy to do if we had no censored data and no ties. There, the basic idea
# would be to iterate over the cases in order of their true event time (from least to greatest),
# while keeping track of a pool of *predicted* event times for all cases previously seen (= all
# cases that we know should be ranked lower than the case we're looking at currently).
#
# If the pool has O(log n) insert and O(log n) RANK (i.e., "how many things in the pool have
# value less than x"), then the following algorithm is n log n:
#
# Sort the times and predictions by time, increasing
# n_pairs, n_correct := 0
# pool := {}
# for each prediction p:
# n_pairs += len(pool)
# n_correct += rank(pool, p)
# add p to pool
#
# There are three complications: tied ground truth values, tied predictions, and censored
# observations.
#
# - To handle tied true event times, we modify the inner loop to work in *batches* of observations
# p_1, ..., p_n whose true event times are tied, and then add them all to the pool
# simultaneously at the end.
#
# - To handle tied predictions, which should each count for 0.5, we switch to
# n_correct += min_rank(pool, p)
# n_tied += count(pool, p)
#
# - To handle censored observations, we handle each batch of tied, censored observations just
# after the batch of observations that died at the same time (since those censored observations
# are comparable all the observations that died at the same time or previously). However, we do
# NOT add them to the pool at the end, because they are NOT comparable with any observations
# that leave the study afterward--whether or not those observations get censored.
died_mask = event_observed.astype(bool)
# TODO: is event_times already sorted? That would be nice...
died_truth = event_times[died_mask]
ix = np.argsort(died_truth)
died_truth = died_truth[ix]
died_pred = predicted_event_times[died_mask][ix]
censored_truth = event_times[~died_mask]
ix = np.argsort(censored_truth)
censored_truth = censored_truth[ix]
censored_pred = predicted_event_times[~died_mask][ix]
censored_ix = 0
died_ix = 0
times_to_compare = _BTree(np.unique(died_pred))
num_pairs = 0
num_correct = 0
num_tied = 0
def handle_pairs(truth, pred, first_ix):
"""
Handle all pairs that exited at the same time as truth[first_ix].
Returns:
(pairs, correct, tied, next_ix)
new_pairs: The number of new comparisons performed
new_correct: The number of comparisons correctly predicted
next_ix: The next index that needs to be handled
"""
next_ix = first_ix
while next_ix < len(truth) and truth[next_ix] == truth[first_ix]:
next_ix += 1
pairs = len(times_to_compare) * (next_ix - first_ix)
correct = 0
tied = 0
for i in range(first_ix, next_ix):
rank, count = times_to_compare.rank(pred[i])
correct += rank
tied += count
return (pairs, correct, tied, next_ix)
# we iterate through cases sorted by exit time:
# - First, all cases that died at time t0. We add these to the sortedlist of died times.
# - Then, all cases that were censored at time t0. We DON'T add these since they are NOT
# comparable to subsequent elements.
while True:
has_more_censored = censored_ix < len(censored_truth)
has_more_died = died_ix < len(died_truth)
# Should we look at some censored indices next, or died indices?
if has_more_censored and (not has_more_died
or died_truth[died_ix] > censored_truth[censored_ix]):
pairs, correct, tied, next_ix = handle_pairs(censored_truth, censored_pred, censored_ix)
censored_ix = next_ix
elif has_more_died and (not has_more_censored
or died_truth[died_ix] <= censored_truth[censored_ix]):
pairs, correct, tied, next_ix = handle_pairs(died_truth, died_pred, died_ix)
for pred in died_pred[died_ix:next_ix]:
times_to_compare.insert(pred)
died_ix = next_ix
else:
assert not (has_more_died or has_more_censored)
break
num_pairs += pairs
num_correct += correct
num_tied += tied
if num_pairs == 0:
raise ZeroDivisionError("No admissable pairs in the dataset.")
return (num_correct + num_tied / 2) / num_pairs
def _naive_concordance_index(event_times, predicted_event_times, event_observed):
"""
Fallback, simpler method to compute concordance.
Assumes the data has been verified by lifelines.utils.concordance_index first.
"""
def valid_comparison(time_a, time_b, event_a, event_b):
"""True if times can be compared."""
if time_a == time_b:
# Ties are only informative if exactly one event happened
return event_a != event_b
elif event_a and event_b:
return True
elif event_a and time_a < time_b:
return True
elif event_b and time_b < time_a:
return True
else:
return False
def concordance_value(time_a, time_b, pred_a, pred_b):
if pred_a == pred_b:
# Same as random
return 0.5
elif pred_a < pred_b:
return (time_a < time_b) or (time_a == time_b and event_a and not event_b)
else: # pred_a > pred_b
return (time_a > time_b) or (time_a == time_b and not event_a and event_b)
paircount = 0.0
csum = 0.0
for a in range(0, len(event_times)):
time_a = event_times[a]
pred_a = predicted_event_times[a]
event_a = event_observed[a]
# Don't want to double count
for b in range(a + 1, len(event_times)):
time_b = event_times[b]
pred_b = predicted_event_times[b]
event_b = event_observed[b]
if valid_comparison(time_a, time_b, event_a, event_b):
paircount += 1.0
csum += concordance_value(time_a, time_b, pred_a, pred_b)
if paircount == 0:
raise ZeroDivisionError("No admissable pairs in the dataset.")
return csum / paircount
def pass_for_numeric_dtypes_or_raise(df):
nonnumeric_cols = df.select_dtypes(exclude=[np.number, bool]).columns.tolist()
if len(nonnumeric_cols) > 0:
raise TypeError("DataFrame contains nonnumeric columns: %s. Try using pandas.get_dummies to convert the column(s) to numerical data, or dropping the column(s)." % nonnumeric_cols)
def check_for_overlapping_intervals(df):
# only useful for time varying coefs, after we've done
# some index creation
# so slow.
if not df.groupby(level=1).apply(lambda g: g.index.get_level_values(0).is_non_overlapping_monotonic).all():
raise ValueError("The dataset provided contains overlapping intervals. Check the start and stop col by id carefully. Try using this code snippet\
to help find:\
df.groupby(level=1).apply(lambda g: g.index.get_level_values(0).is_non_overlapping_monotonic)")
def _low_var(df):
return (df.var(0) < 10e-5)
def check_low_var(df, prescript="", postscript=""):
low_var = _low_var(df)
if low_var.any():
cols = str(list(df.columns[low_var]))
warning_text = "%sColumn(s) %s have very low variance. \
This may harm convergence. Try dropping this redundant column before fitting \
if convergence fails.%s" % (prescript, cols, postscript)
warnings.warn(warning_text, ConvergenceWarning)
def check_complete_separation_low_variance(df, events):
events = events.astype(bool)
rhs = df.columns[_low_var(df.loc[events])]
lhs = df.columns[_low_var(df.loc[~events])]
inter = lhs.intersection(rhs).tolist()
if inter:
warning_text = "Column(s) %s have very low variance when conditioned on \
death event or not. This may harm convergence. This could be a form of 'complete separation'. \
See https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/ " % (inter)
warnings.warn(warning_text, ConvergenceWarning)
def check_complete_separation_close_to_perfect_correlation(df, durations):
THRESHOLD = 0.99
for col, series in df.iteritems():
if abs(stats.spearmanr(series, durations).correlation) >= THRESHOLD:
warning_text = "Column %s has high correlation with the duration column. This may harm convergence. This could be a form of 'complete separation'. \
See https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/ " % (col)
warnings.warn(warning_text, ConvergenceWarning)
def check_complete_separation(df, events, durations):
check_complete_separation_low_variance(df, events)
check_complete_separation_close_to_perfect_correlation(df, durations)
def check_nans(array):
if pd.isnull(array).any():
raise TypeError("NaNs were detected in the duration_col and/or the event_col")
def to_long_format(df, duration_col):
"""
Parameters:
df: a Dataframe in the standard survival analysis form (one for per observation, with covariates, duration and event flag)
duration_col: string representing the column in df that represents the durations of each subject.
Returns:
long_form_df: A DataFrame with columns. This can be fed into `add_covariate_to_timeline`
"""
return df.assign(start=0, stop=lambda s: s[duration_col])\
.drop(duration_col, axis=1)
def add_covariate_to_timeline(long_form_df, cv, id_col, duration_col, event_col, add_enum=False, overwrite=True, cumulative_sum=False, cumulative_sum_prefix="cumsum_"):
"""
This is a util function to help create a long form table tracking subjects' covariate changes over time. It is meant
to be used iteratively as one adds more and more covariates to track over time. If beginning to use this function, it is recommend
to view the docs at https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#dataset-for-time-varying-regression.
Parameters:
long_form_df: a DataFrame that has the intial or intermediate "long" form of time-varying observations. Must contain
columns id_col, 'start', 'stop', and event_col. See function `to_long_format` to transform data into long form.
cv: a DataFrame that contains (possibly more than) one covariate to track over time. Must contain columns
id_col and duration_col. duration_col represents time since the start of the subject's life.
id_col: the column in long_form_df and cv representing a unique identifier for subjects.
duration_col: the column in cv that represents the time-since-birth the observation occured at.
event_col: the column in df that represents if the event-of-interest occured
add_enum: a Boolean flag to denote whether to add a column enumerating rows per subject. Useful to specify a specific
observation, ex: df[df['enum'] == 1] will grab the first observations per subject.
overwrite: if True, covariate values in long_form_df will be overwritten by covariate values in cv if the column exists in both
cv and long_form_df and the timestamps are identical. If False, the default behaviour will be to sum
the values together.
cumulative_sum: sum over time the new covariates. Makes sense if the covariates are new additions, and not state changes (ex:
administering more drugs vs taking a temperature.)
Returns:
long_form_df: A DataFrame with updated rows to reflect the novel times slices (if any) being added from cv, and novel (or updated) columns
of new covariates from cv
"""
def remove_redundant_rows(cv):
"""
Removes rows where no change occurs. Ex:
cv = pd.DataFrame.from_records([
{'id': 1, 't': 0, 'var3': 0, 'var4': 1},
{'id': 1, 't': 1, 'var3': 0, 'var4': 1}, # redundant, as nothing changed during the interval
{'id': 1, 't': 6, 'var3': 1, 'var4': 1},
])
If cumulative_sum, then redundant rows are not redundant.
"""
if cumulative_sum:
return cv
cols = cv.columns.difference([duration_col])
cv = cv.loc[(cv[cols].shift() != cv[cols]).any(axis=1)]
return cv
def transform_cv_to_long_format(cv):
return cv.rename(columns={duration_col: 'start'})
def construct_new_timeline(original_timeline, additional_timeline, final_stop_time):
if additional_timeline.min() < original_timeline.min():
warning_text = "There exists at least one row in the covariates dataset that is before the earlist \
known observation. This could case null values in the resulting dataframe."
warnings.warn(warning_text, RuntimeWarning)
return np.sort(original_timeline.append(additional_timeline).unique())
def expand(df, cvs):
id_ = df.name
try:
cv = cvs.get_group(id_)
except KeyError:
return df
final_state = bool(df[event_col].iloc[-1])
final_stop_time = df['stop'].iloc[-1]
df = df.drop([id_col, event_col, 'stop'], axis=1).set_index("start")
cv = cv.drop([id_col], axis=1)\
.set_index("start")\
.loc[:final_stop_time]
if cumulative_sum:
cv = cv.cumsum()
cv = cv.add_prefix(cumulative_sum_prefix)
# How do I want to merge existing columns at the same time - could be
# new observations (update) or new treatment applied (sum).
# There may be more options in the future.
if not overwrite:
expanded_df = cv.combine(df, lambda s1, s2: s1 + s2, fill_value=0, overwrite=False)
elif overwrite:
expanded_df = cv.combine_first(df)
n = expanded_df.shape[0]
expanded_df = expanded_df.reset_index()
expanded_df['stop'] = expanded_df['start'].shift(-1)
expanded_df[id_col] = id_
expanded_df[event_col] = False
expanded_df.at[n - 1, event_col] = final_state
expanded_df.at[n - 1, 'stop'] = final_stop_time
if add_enum:
expanded_df['enum'] = np.arange(1, n + 1)
if cumulative_sum:
expanded_df[cv.columns] = expanded_df[cv.columns].fillna(0)
return expanded_df.ffill()
if 'stop' not in long_form_df.columns or 'start' not in long_form_df.columns:
raise IndexError("The columns `stop` and `start` must be in long_form_df - perhaps you need to use `lifelines.utils.to_long_format` first?")
cv = cv.dropna()
cv = cv.sort_values([id_col, duration_col])
cvs = cv.pipe(remove_redundant_rows)\
.pipe(transform_cv_to_long_format)\
.groupby(id_col)
long_form_df = long_form_df.groupby(id_col, group_keys=False)\
.apply(expand, cvs=cvs)
return long_form_df.reset_index(drop=True)
def covariates_from_event_matrix(df, id_col):
"""
This is a helper function to handle binary event datastreams in a specific format and convert
it to a format that add_covariate_to_timeline will accept. For example, suppose you have a
dataset that looks like:
id promotion movement raise
0 1 1.0 NaN 2.0
1 2 NaN 5.0 NaN
2 3 3.0 5.0 7.0
where the values (aside from the id column) represent when an event occured for a specific user, relative
to the subject's birth/entry. This is a common way format to pull data from a SQL table. We call this a duration matrix, and we
want to convert this dataframe to a format that can be included in a long form dataframe
(see add_covariate_to_timeline for more details on this).
The duration matrix should have 1 row per subject (but not necessarily all subjects).
Example:
cv = covariates_from_event_matrix(duration_df, 'id')
long_form_df = add_covariate_to_timeline(long_form_df, cv, 'id', 'duration', 'e', cumulative_sum=True)
Parameters:
id_col: the column in long_form_df and cv representing a unique identifier for subjects.
"""
df = df.set_index(id_col)
df = df.stack().reset_index()
df.columns = [id_col, 'event', 'duration']
df['_counter'] = 1
return df.pivot_table(index=[id_col, 'duration'], columns='event', fill_value=0)['_counter'].reset_index()
| 40.400164 | 187 | 0.626619 |
ace05ac532fabbf6e052e84b9dd06d7cfed59f3a | 3,892 | py | Python | predictPrPlus/gui/intrinsicEditor.py | mgleeming/PredictPrPlus | e6810a84e8ef1e9c2f5fb56ddf8bb20fe8e7d7b7 | [
"FSFAP"
] | 2 | 2017-08-26T03:09:04.000Z | 2018-02-23T03:43:24.000Z | predictPrPlus/gui/intrinsicEditor.py | mgleeming/PredictPrPlus | e6810a84e8ef1e9c2f5fb56ddf8bb20fe8e7d7b7 | [
"FSFAP"
] | null | null | null | predictPrPlus/gui/intrinsicEditor.py | mgleeming/PredictPrPlus | e6810a84e8ef1e9c2f5fb56ddf8bb20fe8e7d7b7 | [
"FSFAP"
] | null | null | null | # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'intrinsicEditor.ui'
#
# Created: Sat Mar 18 17:11:07 2017
# by: PyQt4 UI code generator 4.10.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_Dialog(object):
def setupUi(self, Dialog):
Dialog.setObjectName(_fromUtf8("Dialog"))
Dialog.resize(389, 486)
self.gridLayout = QtGui.QGridLayout(Dialog)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.verticalLayout_2 = QtGui.QVBoxLayout()
self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
self.verticalLayout = QtGui.QVBoxLayout()
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.label = QtGui.QLabel(Dialog)
self.label.setObjectName(_fromUtf8("label"))
self.verticalLayout.addWidget(self.label)
self.label_2 = QtGui.QLabel(Dialog)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.verticalLayout.addWidget(self.label_2)
self.verticalLayout_2.addLayout(self.verticalLayout)
self.intrinsicTable = QtGui.QTableWidget(Dialog)
self.intrinsicTable.setObjectName(_fromUtf8("intrinsicTable"))
self.intrinsicTable.setColumnCount(3)
self.intrinsicTable.setRowCount(0)
item = QtGui.QTableWidgetItem()
self.intrinsicTable.setHorizontalHeaderItem(0, item)
item = QtGui.QTableWidgetItem()
self.intrinsicTable.setHorizontalHeaderItem(1, item)
item = QtGui.QTableWidgetItem()
self.intrinsicTable.setHorizontalHeaderItem(2, item)
self.verticalLayout_2.addWidget(self.intrinsicTable)
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.intrinsicDone = QtGui.QPushButton(Dialog)
self.intrinsicDone.setObjectName(_fromUtf8("intrinsicDone"))
self.horizontalLayout.addWidget(self.intrinsicDone)
self.intrinsicCancel = QtGui.QPushButton(Dialog)
self.intrinsicCancel.setObjectName(_fromUtf8("intrinsicCancel"))
self.horizontalLayout.addWidget(self.intrinsicCancel)
self.verticalLayout_2.addLayout(self.horizontalLayout)
self.gridLayout.addLayout(self.verticalLayout_2, 0, 0, 1, 1)
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def retranslateUi(self, Dialog):
Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
self.label.setText(_translate("Dialog", "Enter gas-phase basicity or acidity values (kcal/mol) for ", None))
self.label_2.setText(_translate("Dialog", "residue side chains. Otherwise leave fields blank", None))
item = self.intrinsicTable.horizontalHeaderItem(0)
item.setText(_translate("Dialog", "Residue", None))
item = self.intrinsicTable.horizontalHeaderItem(1)
item.setText(_translate("Dialog", "GBint", None))
item = self.intrinsicTable.horizontalHeaderItem(2)
item.setText(_translate("Dialog", "GAint", None))
self.intrinsicDone.setText(_translate("Dialog", "Done", None))
self.intrinsicCancel.setText(_translate("Dialog", "Cancel", None))
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
Dialog = QtGui.QDialog()
ui = Ui_Dialog()
ui.setupUi(Dialog)
Dialog.show()
sys.exit(app.exec_())
| 42.769231 | 116 | 0.707605 |
ace05b07a0c7858894335a1166e2895eb8dcd7cb | 1,124 | py | Python | tests/event_handler/test_event_handler_registration.py | mpsiva89/protean | 315fa56da3f64178bbbf0edf1995af46d5eb3da7 | [
"BSD-3-Clause"
] | null | null | null | tests/event_handler/test_event_handler_registration.py | mpsiva89/protean | 315fa56da3f64178bbbf0edf1995af46d5eb3da7 | [
"BSD-3-Clause"
] | null | null | null | tests/event_handler/test_event_handler_registration.py | mpsiva89/protean | 315fa56da3f64178bbbf0edf1995af46d5eb3da7 | [
"BSD-3-Clause"
] | null | null | null | import pytest
from protean import BaseAggregate, BaseEvent, BaseEventHandler
from protean.fields import Identifier, String
from protean.utils import fully_qualified_name
class User(BaseAggregate):
email = String()
name = String()
class Registered(BaseEvent):
user_id = Identifier()
email = String()
def test_registering_an_event_handler_manually(test_domain):
class UserEventHandlers(BaseEventHandler):
pass
try:
test_domain.register(UserEventHandlers, aggregate_cls=User)
except Exception:
pytest.fail("Failed to register an Event Handler manually")
assert (
fully_qualified_name(UserEventHandlers) in test_domain.registry.event_handlers
)
def test_registering_an_event_handler_via_annotation(test_domain):
try:
@test_domain.event_handler(aggregate_cls=User)
class UserEventHandlers(BaseEventHandler):
pass
except Exception:
pytest.fail("Failed to register an Event Handler via annotation")
assert (
fully_qualified_name(UserEventHandlers) in test_domain.registry.event_handlers
)
| 24.977778 | 86 | 0.740214 |
ace05b0c0719d06fd5a2cda422a06d5e6f628768 | 3,440 | py | Python | src/main/initialization.py | dennisschroeder/jetson-detectify | 4a6800ae5aefa1fb9167e2fd4743015b7d751b09 | [
"MIT"
] | 1 | 2021-02-16T08:46:58.000Z | 2021-02-16T08:46:58.000Z | src/main/initialization.py | dennisschroeder/jetson-detectify | 4a6800ae5aefa1fb9167e2fd4743015b7d751b09 | [
"MIT"
] | null | null | null | src/main/initialization.py | dennisschroeder/jetson-detectify | 4a6800ae5aefa1fb9167e2fd4743015b7d751b09 | [
"MIT"
] | null | null | null | import os
import uuid
from dataclasses import dataclass
from datetime import datetime
from . import FilePath, DirPath, Topic
from .util import create_directory, FileCreationException, DirectoryCreationException, create_file_from_str_to, \
create_file_from_dict_to
from .console_logging import print_success_step, print_error_step
@dataclass
class ApplicationSettings:
application_base_dir: DirPath
application_storage_dir: DirPath
application_init_report_file: FilePath
application_settings_file: FilePath
sensors_config_file: FilePath
root_topic: Topic
def create_default_application_settings() -> ApplicationSettings:
return ApplicationSettings(
application_base_dir=DirPath(os.path.expanduser("~/.jetson_detectify")),
application_storage_dir=DirPath(os.path.expanduser("~/.jetson_detectify/.storage")),
application_init_report_file=FilePath(os.path.expanduser("~/.jetson_detectify/.storage/init.json")),
application_settings_file=FilePath(os.path.expanduser("~/.jetson_detectify/application.yaml")),
sensors_config_file=FilePath(os.path.expanduser("~/.jetson_detectify/sensor.yaml")),
root_topic=Topic("homeassistant")
)
def write_init_report_to(dir_path: DirPath):
now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
try:
content = {"success": True, "last_init_run": now, "node_id": "jetson_detectify", "device_id": uuid.uuid4().hex}
create_file_from_dict_to(FilePath(f"{dir_path}/init.json"), content)
print_success_step(f"Init-Report creation to [{dir_path}] successful.")
except FileCreationException as error:
print_error_step(
f"Init-Report creation to [{dir_path}] failed. I/O error({error.cause.strerror}): {error.cause.strerror}")
def create_application_settings_file(settings: ApplicationSettings):
create_application_directory(settings.application_base_dir)
create_application_directory(settings.application_storage_dir)
mqtt_broker = f"""mqtt_broker:
username: username
password: password
host: localhost
port: 1883
root_topic: {settings.root_topic}
"""
create_application_file(settings.application_settings_file, mqtt_broker)
def create_sensors_config_file(settings: ApplicationSettings):
content = """sensor: []
"""
create_application_file(settings.sensors_config_file, content)
def create_application_directory(dir_path: DirPath):
if not os.path.exists(dir_path):
try:
create_directory(dir_path)
print_success_step(f"Creating directory [{dir_path}] succeeded")
return
except DirectoryCreationException as error:
print_error_step(
f"Creating directory [{dir_path}] failed! OS error({error.cause.strerror}): {error.cause.strerror}")
print_success_step(f"Directory [{dir_path}] already exists!")
def create_application_file(file_path: FilePath, content: str):
if not os.path.exists(file_path):
try:
create_file_from_str_to(file_path=file_path, content=content)
print_success_step(f"Creating file [{file_path}] succeeded")
return
except FileCreationException as error:
print_error_step(
f"Creating file [{file_path}] failed! I/O error({error.cause.errno}): {error.cause.strerror}")
print_success_step(f"File [{file_path}] already exists!")
| 38.651685 | 119 | 0.729942 |
ace05b2d2917e7746179ef2dadb6d7fd39e1dcaa | 1,785 | py | Python | vframe/vcat/utils/vcat_api.py | kant/vframe | 28e49ca62d9036a78a25b26eb0fb7e3cf8c79031 | [
"MIT"
] | 1 | 2021-04-18T10:42:10.000Z | 2021-04-18T10:42:10.000Z | vframe/vcat/utils/vcat_api.py | vframeio/_vframe_v0_archived | 28e49ca62d9036a78a25b26eb0fb7e3cf8c79031 | [
"MIT"
] | null | null | null | vframe/vcat/utils/vcat_api.py | vframeio/_vframe_v0_archived | 28e49ca62d9036a78a25b26eb0fb7e3cf8c79031 | [
"MIT"
] | null | null | null | import sys
import os
from os.path import join
import json
import requests
from vframe.settings import vframe_cfg as cfg
from vcat.settings import vcat_cfg
from vframe.utils import logger_utils
# --------------------------------------------------------
# Downloads data from VCAT API
# --------------------------------------------------------
class API:
def __init__(self, un, pw):
self.log = logger_utils.Logger.getLogger()
if not un or not pw:
self.log.error('Username and/or password not supplied')
sys.exit()
self.un = un
self.pw = pw
# TODO move to config
self.hierarchy_url = vcat_cfg.VCAT_HIERARCHY_URL
def get_hierarchy(self):
try:
hierarchy_raw = requests.get(self.hierarchy_url, auth=(self.un, self.pw)).json()
except:
self.log.error('Could not get data from: {}'.format(self.hierarchy_url))
return {}
return { int(class_meta['id']): class_meta for class_meta in hierarchy_raw }
def request_regions(self, class_id):
url = join(self.hierarchy_url, class_id, 'regions')
return requests.get(url,auth=(self.un, self.pw)).json()
def get_class(self, class_id):
"""get single class, but with same format"""
object_classes = { class_id: self.request_regions(class_id) }
return {'object_classes': object_classes}
def get_full(self):
objs_regions = {}
hierarchy = self.get_hierarchy()
for hierarchy_id, hierarchy_obj in hierarchy.items():
if int(hierarchy_obj['region_count']) > 0:
slug = hierarchy_obj['slug'].replace(':','').replace('-','_')
cat_id = str(hierarchy_obj['id'])
obj_regions = self.request_regions(cat_id)
objs_regions[cat_id] = obj_regions
return {'hierarchy':hierarchy, 'object_classes':objs_regions}
| 28.790323 | 86 | 0.642577 |
ace05bb4da7b061e55434aba2109bf5c00f77b1a | 161 | py | Python | s2cholar/api/__init__.py | luizvbo/s2cholar | 7f2be800168ef792230f7759bc7131c5f59e2103 | [
"MIT"
] | 1 | 2021-12-03T13:02:34.000Z | 2021-12-03T13:02:34.000Z | s2cholar/api/__init__.py | luizvbo/s2cholar | 7f2be800168ef792230f7759bc7131c5f59e2103 | [
"MIT"
] | null | null | null | s2cholar/api/__init__.py | luizvbo/s2cholar | 7f2be800168ef792230f7759bc7131c5f59e2103 | [
"MIT"
] | null | null | null | from __future__ import absolute_import
# import apis into api package
from s2cholar.api.author_api import AuthorApi
from s2cholar.api.paper_api import PaperApi
| 26.833333 | 45 | 0.850932 |
ace05c76e7757060a822496cfade46aa953cec3f | 4,840 | py | Python | multiple_map_DR12.py | EuniceChen1/SummerProject2015 | 03252237aa0feb75ebaeaae6bcb730006e6600c6 | [
"MIT"
] | null | null | null | multiple_map_DR12.py | EuniceChen1/SummerProject2015 | 03252237aa0feb75ebaeaae6bcb730006e6600c6 | [
"MIT"
] | null | null | null | multiple_map_DR12.py | EuniceChen1/SummerProject2015 | 03252237aa0feb75ebaeaae6bcb730006e6600c6 | [
"MIT"
] | null | null | null | from __future__ import division, print_function
import numpy as np
import os
import glob
import healpy as hp
from astropy.table import Table
import argparse
import ast
import pandas as pd
#--------------------------------- LOGIC
'''
Have multiple unprocessed galaxy catalogs.
Use a for loop and input those catalogs to cut them one by one.
Get processed catalogs from the for loop.
Input processed catalogs into bin_data function and bin the processed catalogs.
Use a for loop in the bin_data function to bin the catalogs one by one.
Binned catalogs inputted into the main function for loop to create a full count map.
'''
#-----------------------------------
def apply_cuts(data):
#sdss = Table.read(fnames, format='csv')
# Part 1: Filtering the catalog with only galaxy type
separation = data['type']
galaxy = (separation == 6)
data = data[galaxy]
# Part 2: Choosing on clean photometry (sdss['clean'] = 1)
cleaning = data['clean']
clearimage = (cleaning == 1)
data = data[clearimage]
# Part 3: Choosing image mask
mask = data['insideMask']
maskmap = (mask == 0)
data = data[maskmap]
newdata = data['ra','dec','type','clean','insideMask']
return newdata
def bin_data(data,field,binlist):
bincolumn = data[field]
bindata = ((bincolumn >= inf) & (bincolumn < sup) for (inf, sup) in binlist)
datalist = [data[mask] for mask in bindata]
return datalist
def main(infile, nside, RA, DEC, zname, zbins, cuts):
filelist = glob.glob(infile)
filelist.sort()
folder = os.getcwd()
# Create empty Healpix map
full_countmap = np.zeros(hp.nside2npix(nside))
# Get number of pixels from the map
npix = hp.nside2npix(nside)
for filename in filelist:
# 1) Open catalogs and perform checks
filepath = os.path.join(folder, filename)
print (filepath)
# Open the catalog as a table
data = Table(np.array(pd.read_csv(filepath,skiprows=1)))
#Check if the file is empty
if (len(data) == 0):
print ("file is empty")
continue
else:
print ("file is not empty")
#Renaming columns
selectcols = ["col0","col1","col2","col9","col10","col12"]
newcolnames = ["objID","ra","dec","type","clean","insideMask"]
for oldname, newname in zip(selectcols, newcolnames):
data.rename_column(oldname,newname)
colnames = data.columns
# Make sure that RA and DEC columns are in the catalog
assert (RA in colnames) and (DEC in colnames), ("Both ra and dec must" +
"be in the catalog")
# Make sure that Nside is a power of 2
assert hp.isnsideok(nside), "nside must be a power of 2"
# 2) Apply general cuts and bin in redshift
# Apply general cuts to catalog
if cuts is not None:
data = apply_cuts(data)
# Apply redshift bin
# NEED TO CHANGE DATA TO DATALIST FOR THE REST OF THE CODE TO APPLY REDSHIFT BINNING
"""
if (zname is not None) and (zbins is not None):
datalist = bin_data(data, zname, zbins)
zsuffix = ["_z%.2f-%.2f" % (inf, sup) for (inf, sup) in zbins]
else:
print ("For redshift binning, both zname and zbins must be given.")
print ("Proceeding without binning.")
datalist = [data]
zsuffix = [""]
"""
# 3) Create count maps for each redshift bin
# Translate radec coordinates to healpix format
theta = np.deg2rad(90.0 - data['dec'])
phi = np.deg2rad(data['ra'])
# Affect each galaxy to a healpix pixel
try:
gal_hppix = hp.ang2pix(nside, theta=theta, phi=phi, nest=False)
except ValueError:
print("BEWARE! Problem with RA DEC range, creating fake random map.")
theta = np.random.uniform(0, np.pi, size=len(data))
phi = np.random.uniform(0, 2*np.pi, size=len(data))
gal_hppix = hp.ang2pix(nside, theta=theta, phi=phi, nest=False)
# Count number of galaxies in each pixel
countmap = np.bincount(gal_hppix, minlength=npix)
# Make sure size of count map is the same as number of pixels
assert len(countmap) == npix, ("Size of count map must be the same" +
"as minimum length")
# Add counts to the originally empty map
full_countmap += countmap
# Save final map
savemap = hp.write_map("/share/splinter/visit10/sdss_full_countmap_DR12.fits", full_countmap)
return None
if __name__ == "__main__":
#infile = "/share/splinter/moraes/photoz_cats/photoz_cat_*.csv"
infile = "/share/data1/SDSS_DR12_Photometry/UCLimaging*.csv"
nside = 128
RA = 'ra'
DEC = 'dec'
zname = 'field' #NEED TO CHANGE BACK TO Z, DR12 DATA DOES NOT HAVE PHOTOZ COLUMN
zbins = [(0.,0.10),(0.11,0.20),(0.21,0.30),(0.31,0.40),(0.41,0.50),(0.51,0.60),(0.61,0.70),(0.71,0.80),(0.81,0.90),(0.91,1.00)]
cuts = None
main(infile, nside, RA, DEC, zname, zbins, cuts)
| 32.05298 | 131 | 0.649793 |
ace05e1476c4fb9e35d9a2e288e23c9742546524 | 2,075 | py | Python | direct_input.py | SleepUnit/OpenStickFirmware | 9a8fcb8543a04dfb85c545fdd276072b56a631f8 | [
"MIT"
] | 17 | 2021-08-06T22:20:51.000Z | 2022-03-17T02:42:00.000Z | direct_input.py | SleepUnit/OpenStickFirmware | 9a8fcb8543a04dfb85c545fdd276072b56a631f8 | [
"MIT"
] | 2 | 2021-08-08T00:23:48.000Z | 2021-08-08T00:24:53.000Z | direct_input.py | SleepUnit/OpenStickFirmware | 9a8fcb8543a04dfb85c545fdd276072b56a631f8 | [
"MIT"
] | 3 | 2021-08-16T04:22:49.000Z | 2021-09-03T06:12:09.000Z | import usb_hid
class DirectInput:
def __init__(self):
self.report_id = 7
def descriptor(self):
return bytes((
0x05, 0x01, # USAGE_PAGE (Generic Desktop)
0x09, 0x05, # USAGE (Gamepad) - Very important for Switch
0xa1, 0x01, # COLLECTION (Application)
0x85, 0xFF, # 7 [SET AT RUNTIME]
# 16 Buttons
0x05, 0x09, # USAGE_PAGE (Button)
0x19, 0x01, # USAGE_MINIMUM (Button 1)
0x29, 0x10, # USAGE_MAXIMUM (Button 16)
0x15, 0x00, # LOGICAL_MINIMUM (0)
0x25, 0x01, # LOGICAL_MAXIMUM (1)
0x75, 0x01, # REPORT_SIZE (1)
0x95, 0x10, # REPORT_COUNT (16)
0x55, 0x00, # UNIT_EXPONENT (0)
0x65, 0x00, # UNIT (None)
0x81, 0x02, # INPUT (Data,Var,Abs)
# One Hat switches (8 Positions)
0x05, 0x01, # USAGE_PAGE (Generic Desktop)
0x09, 0x39, # USAGE (Hat switch)
0x15, 0x00, # LOGICAL_MINIMUM (0)
0x25, 0x07, # LOGICAL_MAXIMUM (7)
0x35, 0x00, # PHYSICAL_MINIMUM (0)
0x46, 0x3B, 0x01, # PHYSICAL_MAXIMUM (315)
0x65, 0x14, # UNIT (Eng Rot:Angular Pos)
0x75, 0x04, # REPORT_SIZE (4)
0x95, 0x01, # REPORT_COUNT (1)
0x81, 0x02, # INPUT (Data,Var,Abs)
0x65, 0x00,
0x95, 0x01,
0x81, 0x01,
# X, Y, and Z Axis
0x15, 0x00, # LOGICAL_MINIMUM (0)
0x26, 0xff, 0x00, # LOGICAL_MAXIMUM (255)
0x75, 0x08, # REPORT_SIZE (8)
0x09, 0x01, # USAGE (Pointer)
0xA1, 0x00, # COLLECTION (Physical)
0x09, 0x30, # USAGE (x)
0x09, 0x31, # USAGE (y)
0x09, 0x32, # USAGE (z)
0x09, 0x35, # USAGE (rz)
0x95, 0x04, # REPORT_COUNT (4)
0x81, 0x02, # INPUT (Data,Var,Abs)
0xc0, # END_COLLECTION
0xc0 # END_COLLECTION
))
def device(self):
return usb_hid.Device(
report_descriptor = self.descriptor(),
usage_page = 0x1,
usage = 0x5,
in_report_length = 7,
out_report_length = 1,
report_id_index = self.report_id,
)
| 30.072464 | 63 | 0.560482 |
ace05e811ef7048351bebae7f4df02a52bd4196c | 6,269 | py | Python | src/spaceone/notification/manager/plugin_manager_bak.py | xellos00/notification | e091c1eaeaf54d2669ac204c027aacddabad382a | [
"Apache-2.0"
] | null | null | null | src/spaceone/notification/manager/plugin_manager_bak.py | xellos00/notification | e091c1eaeaf54d2669ac204c027aacddabad382a | [
"Apache-2.0"
] | null | null | null | src/spaceone/notification/manager/plugin_manager_bak.py | xellos00/notification | e091c1eaeaf54d2669ac204c027aacddabad382a | [
"Apache-2.0"
] | null | null | null | import logging
from spaceone.core.manager import BaseManager
from spaceone.notification.error.plugin import *
__ALL__ = ['PluginManager']
_LOGGER = logging.getLogger(__name__)
"""
Base on plugin_info from collector_vo
This class act for general interface with real collector plugin
"""
class PluginManager(BaseManager):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def init(self, params):
""" Init plugin with params.plugin_info
Returns: plugin_info(metadata)
"""
plugin_info = params.get('plugin_info', {})
domain_id = params['domain_id']
return self._init_by_plugin_info(plugin_info, domain_id)
def verify(self, params):
""" Verify plugin with params.plugin_info
After verify, plugin_info.options will be updated
Returns: verified_params
"""
plugin_info = params.get('plugin_info', {})
domain_id = params['domain_id']
return self.verify_by_plugin_info(plugin_info, domain_id)
def verify_by_plugin_info(self, plugin_info, domain_id, secret_id=None):
self._check_plugin_info(plugin_info)
plugin_id = plugin_info['plugin_id']
version = plugin_info['version']
labels = plugin_info.get('labels', {})
options = plugin_info.get('options', {})
secret_id_list = self.get_secrets_from_plugin_info(plugin_info, domain_id, secret_id)
endpoint = self.get_endpoint(plugin_id, version, domain_id, labels)
_LOGGER.debug(f'[verify] endpoint: {endpoint} of plugin: {plugin_id}, {version}, {len(secret_id_list)}')
verified = False
for secret_id in secret_id_list:
try:
secret_data = self._get_secret_data(secret_id, domain_id)
_LOGGER.debug(f'[verify] secret_data.keys: {list(secret_data)}')
verified_options = self.verify_plugin(endpoint, options, secret_data)
verified = True
except Exception as e:
_LOGGER.debug(f'[verify] {e}')
_LOGGER.warn(f'[verify] fail to verify with secret: {secret_id}')
if verified and verified_options != None:
return verified_options
raise ERROR_VERIFY_PLUGIN_FAILURE(params=plugin_info)
def get_secrets_from_plugin_info(self, plugin_info, domain_id, secret_id=None):
self._check_plugin_info(plugin_info)
secret_id_list = self._get_secret_id_list(plugin_info, domain_id)
if secret_id:
if is_member(secret_id, secret_id_list):
secret_id_list = [secret_id]
else:
_LOGGER.error(f'[verify_by_plugin_info] {secret_id} is not a member of {secret_id_list}')
raise ERROR_VERIFY_PLUGIN_FAILURE(params=secret_id)
_LOGGER.debug(f'[verify] secret_id_list: {secret_id_list}')
return secret_id_list
def get_endpoint(self, plugin_id, version, domain_id):
""" Get plugin endpoint
"""
plugin_connector = self.locator.get_connector('PluginConnector')
return plugin_connector.get_plugin_endpoint(plugin_id, version, domain_id)
def init_plugin(self, endpoint, options):
""" Init plugin
"""
connector = self.locator.get_connector('PluginConnector')
connector.initialize(endpoint)
return connector.init(options)
def verify_plugin(self, endpoint, options, secret_data):
""" Verify plugin
"""
connector = self.locator.get_connector('PluginConnector')
connector.initialize(endpoint)
return connector.verify(options, secret_data)
def _check_plugin_info(self, plugin_info):
""" Plugin Info has
- plugin_id (mendatory)
- version (mendatory)
- options (optional)
- metadata (optional)
Returns: True
Raise: ERROR_PLUGIN_PARAMETER
"""
mendatory = ['plugin_id', 'version']
for item in mendatory:
if item not in plugin_info:
raise ERROR_NO_PLUGIN_PARAMETER(param=item)
return True
def _get_secret_id_list(self, plugin_info, domain_id):
"""
Return: list of secret ID
"""
secret_group_id = plugin_info.get('secret_group_id', None)
secret_id = plugin_info.get('secret_id', None)
provider = plugin_info.get('provider', None)
_LOGGER.debug(f'[_get_secret_id_list] {secret_id}, {secret_group_id}, {provider}')
if provider and (secret_group_id or secret_id):
_LOGGER.warning(f'[_get_secret_id_list] both provider and (secret_group_id or secret_id) \
exist at {plugin_info}')
_LOGGER.warning(f'[_get_secret_id_list] use minimum set: {secret_group_id} or {secret_id}')
provider = None
secret_mgr = self.locator.get_manager('SecretManager')
result_list = []
if provider:
result_list.extend(secret_mgr.get_secret_ids_from_provider(provider, domain_id))
if secret_group_id:
result_list.extend(secret_mgr.get_secret_ids_from_secret_group_id(secret_group_id))
if secret_id:
result_list.append(secret_id)
return result_list
def _get_secret_data(self, secret_id, domain_id):
"""
Return: secret_data (as dict format)
"""
secret_mgr = self.locator.get_manager('SecretManager')
secret_data = secret_mgr.get_secret_data(secret_id, domain_id)
return secret_data.data
def _init_by_plugin_info(self, plugin_info, domain_id):
self._check_plugin_info(plugin_info)
plugin_id = plugin_info['plugin_id']
version = plugin_info['version']
options = plugin_info.get('options', {})
metadata = plugin_info.get('metadata', {})
endpoint = self.get_endpoint(plugin_id, version, domain_id)
_LOGGER.debug(f'[verify] endpoint: {endpoint} of plugin: {plugin_id}, {version}')
plugin_meta = self.init_plugin(endpoint, options)
_LOGGER.debug(f'[_init_by_plugin_info] metadata: {plugin_meta}')
return plugin_meta
def is_member(item, seq):
return sum(map(lambda x: x == item, seq)) > 0
| 38.22561 | 112 | 0.653852 |
ace05f0edd143f624142a1806b6a84d227ad9a65 | 5,411 | py | Python | src/parse.py | j0sh77/phnot | 19f6f91a19ced971adc05bd45f3ba5d8cfb1e5ae | [
"MIT"
] | null | null | null | src/parse.py | j0sh77/phnot | 19f6f91a19ced971adc05bd45f3ba5d8cfb1e5ae | [
"MIT"
] | null | null | null | src/parse.py | j0sh77/phnot | 19f6f91a19ced971adc05bd45f3ba5d8cfb1e5ae | [
"MIT"
] | null | null | null | import util
import re
import conf
import auth
from bs4 import BeautifulSoup
import soupsieve
from entities import Notification
class DiffParser():
def _get_new_revision(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) created this revision")
if not util.should_ignore_username(username):
short_message = "{} created a new revision - {}: {}.".format(username, id, desc)
long_message = "@" + short_message
ret = Notification(id, desc, short_message, long_message)
return ret
def _get_request_changes(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) requested changes to this revision.")
if not util.should_ignore_username(username):
short_message = "{} requested changes to {}.".format(username, id)
long_message = "@{} requested changes to {}: {}.".format(username, id, desc)
ret = Notification(id, desc, short_message, long_message)
elif 'This revision now requires changes to proceed' in body:
short_message = "{} requires changes to proceed.".format(id)
long_message = "*{}: {}* requires changes to proceed.".format(id, desc)
ret = Notification(id, desc, short_message, long_message)
return ret
def _get_comments(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) added a comment.")
if not util.should_ignore_username(username):
short_message = "{} added a comment to {}.".format(username, id)
long_message = "@{} added a comment to *{}: {}*.".format(username, id, desc)
soup = BeautifulSoup(body, 'html.parser')
paragraphs = soup.select("div > div > p")
if len(paragraphs) > 0 and len(paragraphs[0].parent.text) > 0:
long_message = "{}\n```{}```".format(long_message, paragraphs[0].parent.text)
ret = Notification(id, desc, short_message, long_message)
return ret
def _get_inline_comments(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) added inline comments")
# found inline comments
if not util.should_ignore_username(username):
short_message = "{} added inline comments to {}.".format(username, id)
long_message = "@{} added inline comments to *{}: {}*.".format(username, id, desc)
soup = BeautifulSoup(body, 'html.parser')
comment_divs = soup.select("div > strong + div > div > div > div")
files = {}
comments = []
# try to find any actual comments
for div in comment_divs:
# filter out those with color - those are old comments
comments = [comment.text for comment in div.select("p") if 'color' not in comment.parent['style']]
for comment in comments:
long_message = "{}\n```{}```".format(long_message, comment)
ret = Notification(id, desc, short_message, long_message)
return ret
def _get_ready_to_land(self, id, desc, body):
ret = None
if 'This revision is now accepted and ready to land.' in body:
short_message = "{} is now accepted and ready to land.".format(id)
long_message = "*{}: {}* is now accepted and ready to land.".format(id, desc)
ret = Notification(id, desc, short_message, long_message)
return ret
def parse(self, id, desc, body):
notifications = [
self._get_inline_comments(id, desc, body),
self._get_comments(id, desc, body),
self._get_request_changes(id, desc, body),
self._get_ready_to_land(id, desc, body),
]
return [n for n in notifications if n is not None]
class TaskParser():
def _get_comments(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) added a comment.")
if not util.should_ignore_username(username):
short_message = "{} added a comment to {}.".format(username, id)
long_message = "@{} added a comment to *{}: {}*.".format(username, id, desc)
soup = BeautifulSoup(body, 'html.parser')
paragraphs = soup.select("div > div > p")
if len(paragraphs) > 0 and len(paragraphs[0].parent.text) > 0:
long_message = "{}\n```{}```".format(long_message, paragraphs[0].parent.text)
ret = Notification(id, desc, short_message, long_message)
return ret
def _get_task_move(self, id, desc, body):
ret = None
username = util.get_regex_match(body, ">([^>]+) moved this task")
movement = util.get_regex_match(body, "moved this task ([^\.]+)")
if not util.should_ignore_username(username):
short_message = "{} moved {} {}.".format(username, id, movement)
long_message = "@{} moved *{}: {}* {}.".format(username, id, desc, movement)
ret = Notification(id, desc, short_message, long_message)
return ret
def parse(self, id, desc, body):
notifications = [
self._get_comments(id, desc, body),
self._get_task_move(id, desc, body),
]
return [n for n in notifications if n is not None]
| 40.684211 | 114 | 0.59453 |
ace05fcd92fcc6dd0dd101f843dfc7daee5751de | 5,120 | py | Python | plugin/storage/es/esCleaner.py | kritika-srivastava/jaeger | f9152de6622323199374f45911421794509015e8 | [
"Apache-2.0"
] | 1 | 2021-07-03T18:53:47.000Z | 2021-07-03T18:53:47.000Z | plugin/storage/es/esCleaner.py | kritika-srivastava/jaeger | f9152de6622323199374f45911421794509015e8 | [
"Apache-2.0"
] | 68 | 2021-03-18T07:42:53.000Z | 2022-03-21T23:10:00.000Z | plugin/storage/es/esCleaner.py | kritika-srivastava/jaeger | f9152de6622323199374f45911421794509015e8 | [
"Apache-2.0"
] | 1 | 2021-03-09T10:17:48.000Z | 2021-03-09T10:17:48.000Z | #!/usr/bin/env python3
import curator
import elasticsearch
import os
import ssl
import sys
TIMEOUT=120
def main():
if len(sys.argv) != 3:
print('USAGE: [INDEX_PREFIX=(default "")] [ARCHIVE=(default false)] ... {} NUM_OF_DAYS http://HOSTNAME[:PORT]'.format(sys.argv[0]))
print('NUM_OF_DAYS ... delete indices that are older than the given number of days.')
print('HOSTNAME ... specifies which Elasticsearch hosts URL to search and delete indices from.')
print('TIMEOUT ... number of seconds to wait for master node response (default {}).'.format(TIMEOUT))
print('INDEX_PREFIX ... specifies index prefix.')
print('INDEX_DATE_SEPARATOR ... specifies index date separator.')
print('ARCHIVE ... specifies whether to remove archive indices (only works for rollover) (default false).')
print('ROLLOVER ... specifies whether to remove indices created by rollover (default false).')
print('ES_USERNAME ... The username required by Elasticsearch.')
print('ES_PASSWORD ... The password required by Elasticsearch.')
print('ES_TLS ... enable TLS (default false).')
print('ES_TLS_CA ... Path to TLS CA file.')
print('ES_TLS_CERT ... Path to TLS certificate file.')
print('ES_TLS_KEY ... Path to TLS key file.')
print('ES_TLS_SKIP_HOST_VERIFY ... (insecure) Skip server\'s certificate chain and host name verification.')
sys.exit(1)
client = create_client(os.getenv("ES_USERNAME"), os.getenv("ES_PASSWORD"), str2bool(os.getenv("ES_TLS", 'false')), os.getenv("ES_TLS_CA"), os.getenv("ES_TLS_CERT"), os.getenv("ES_TLS_KEY"), str2bool(os.getenv("ES_TLS_SKIP_HOST_VERIFY", 'false')))
ilo = curator.IndexList(client)
empty_list(ilo, 'Elasticsearch has no indices')
prefix = os.getenv("INDEX_PREFIX", '')
if prefix != '':
prefix += '-'
separator = os.getenv("INDEX_DATE_SEPARATOR", '-')
if str2bool(os.getenv("ARCHIVE", 'false')):
filter_archive_indices_rollover(ilo, prefix)
else:
if str2bool(os.getenv("ROLLOVER", 'false')):
filter_main_indices_rollover(ilo, prefix)
else:
filter_main_indices(ilo, prefix, separator)
empty_list(ilo, 'No indices to delete')
for index in ilo.working_list():
print("Removing", index)
timeout = int(os.getenv("TIMEOUT", TIMEOUT))
delete_indices = curator.DeleteIndices(ilo, master_timeout=timeout)
delete_indices.do_action()
def filter_main_indices(ilo, prefix, separator):
date_regex = "\d{4}" + separator + "\d{2}" + separator + "\d{2}"
time_string = "%Y" + separator + "%m" + separator + "%d"
ilo.filter_by_regex(kind='regex', value=prefix + "jaeger-(span|service|dependencies)-" + date_regex)
empty_list(ilo, "No indices to delete")
# This excludes archive index as we use source='name'
# source `creation_date` would include archive index
ilo.filter_by_age(source='name', direction='older', timestring=time_string, unit='days', unit_count=int(sys.argv[1]))
def filter_main_indices_rollover(ilo, prefix):
ilo.filter_by_regex(kind='regex', value=prefix + "jaeger-(span|service)-\d{6}")
empty_list(ilo, "No indices to delete")
# do not remove active write indices
ilo.filter_by_alias(aliases=[prefix + 'jaeger-span-write'], exclude=True)
empty_list(ilo, "No indices to delete")
ilo.filter_by_alias(aliases=[prefix + 'jaeger-service-write'], exclude=True)
empty_list(ilo, "No indices to delete")
ilo.filter_by_age(source='creation_date', direction='older', unit='days', unit_count=int(sys.argv[1]))
def filter_archive_indices_rollover(ilo, prefix):
# Remove only rollover archive indices
# Do not remove active write archive index
ilo.filter_by_regex(kind='regex', value=prefix + "jaeger-span-archive-\d{6}")
empty_list(ilo, "No indices to delete")
ilo.filter_by_alias(aliases=[prefix + 'jaeger-span-archive-write'], exclude=True)
empty_list(ilo, "No indices to delete")
ilo.filter_by_age(source='creation_date', direction='older', unit='days', unit_count=int(sys.argv[1]))
def empty_list(ilo, error_msg):
try:
ilo.empty_list_check()
except curator.NoIndices:
print(error_msg)
sys.exit(0)
def str2bool(v):
return v.lower() in ('true', '1')
def create_client(username, password, tls, ca, cert, key, skipHostVerify):
context = ssl.create_default_context()
if ca is not None:
context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=ca)
elif skipHostVerify:
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
if username is not None and password is not None:
return elasticsearch.Elasticsearch(sys.argv[2:], http_auth=(username, password), ssl_context=context)
elif tls:
context.load_cert_chain(certfile=cert, keyfile=key)
return elasticsearch.Elasticsearch(sys.argv[2:], ssl_context=context)
else:
return elasticsearch.Elasticsearch(sys.argv[2:], ssl_context=context)
if __name__ == "__main__":
main()
| 43.389831 | 250 | 0.685547 |
ace060339d2f7d5b953b017ff9ea8e0493f242b5 | 474,158 | py | Python | models_nonconvex_simple/autocorr_bern40-40.py | grossmann-group/pyomo-MINLP-benchmarking | 714f0a0dffd61675649a805683c0627af6b4929e | [
"MIT"
] | 7 | 2019-05-08T19:14:34.000Z | 2021-12-24T00:00:40.000Z | models_nonconvex_simple/autocorr_bern40-40.py | grossmann-group/pyomo-MINLP-benchmarking | 714f0a0dffd61675649a805683c0627af6b4929e | [
"MIT"
] | null | null | null | models_nonconvex_simple/autocorr_bern40-40.py | grossmann-group/pyomo-MINLP-benchmarking | 714f0a0dffd61675649a805683c0627af6b4929e | [
"MIT"
] | 1 | 2019-05-10T18:34:18.000Z | 2019-05-10T18:34:18.000Z | # MINLP written by GAMS Convert at 08/13/20 17:37:48
#
# Equation counts
# Total E G L N X C B
# 1 0 0 1 0 0 0 0
#
# Variable counts
# x b i s1s s2s sc si
# Total cont binary integer sos1 sos2 scont sint
# 41 1 40 0 0 0 0 0
# FX 0 0 0 0 0 0 0 0
#
# Nonzero counts
# Total const NL DLL
# 41 1 40 0
from pyomo.environ import *
model = m = ConcreteModel()
m.b1 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b2 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b3 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b4 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b5 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b6 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b7 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b8 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b9 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b10 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b11 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b12 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b13 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b14 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b15 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b16 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b17 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b18 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b19 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b20 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b21 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b22 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b23 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b24 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b25 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b26 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b27 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b28 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b29 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b30 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b31 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b32 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b33 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b34 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b35 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b36 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b37 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b38 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b39 = Var(within=Binary,bounds=(0,1),initialize=0)
m.b40 = Var(within=Binary,bounds=(0,1),initialize=0)
m.x41 = Var(within=Reals,bounds=(None,None),initialize=0)
m.obj = Objective(expr=m.x41, sense=minimize)
m.c1 = Constraint(expr=64*m.b1*m.b2*m.b3*m.b4 + 64*m.b1*m.b2*m.b4*m.b5 + 64*m.b1*m.b2*m.b5*m.b6 + 64*m.b1*m.b2*m.b6*m.b7
+ 64*m.b1*m.b2*m.b7*m.b8 + 64*m.b1*m.b2*m.b8*m.b9 + 64*m.b1*m.b2*m.b9*m.b10 + 64*m.b1*m.b2*m.b10
*m.b11 + 64*m.b1*m.b2*m.b11*m.b12 + 64*m.b1*m.b2*m.b12*m.b13 + 64*m.b1*m.b2*m.b13*m.b14 + 64*m.b1
*m.b2*m.b14*m.b15 + 64*m.b1*m.b2*m.b15*m.b16 + 64*m.b1*m.b2*m.b16*m.b17 + 64*m.b1*m.b2*m.b17*
m.b18 + 64*m.b1*m.b2*m.b18*m.b19 + 64*m.b1*m.b2*m.b19*m.b20 + 64*m.b1*m.b2*m.b20*m.b21 + 64*m.b1*
m.b2*m.b21*m.b22 + 64*m.b1*m.b2*m.b22*m.b23 + 64*m.b1*m.b2*m.b23*m.b24 + 64*m.b1*m.b2*m.b24*m.b25
+ 64*m.b1*m.b2*m.b25*m.b26 + 64*m.b1*m.b2*m.b26*m.b27 + 64*m.b1*m.b2*m.b27*m.b28 + 64*m.b1*m.b2*
m.b28*m.b29 + 64*m.b1*m.b2*m.b29*m.b30 + 64*m.b1*m.b2*m.b30*m.b31 + 64*m.b1*m.b2*m.b31*m.b32 + 64
*m.b1*m.b2*m.b32*m.b33 + 64*m.b1*m.b2*m.b33*m.b34 + 64*m.b1*m.b2*m.b34*m.b35 + 64*m.b1*m.b2*m.b35
*m.b36 + 64*m.b1*m.b2*m.b36*m.b37 + 64*m.b1*m.b2*m.b37*m.b38 + 64*m.b1*m.b2*m.b38*m.b39 + 64*m.b1
*m.b2*m.b39*m.b40 + 64*m.b1*m.b3*m.b4*m.b6 + 64*m.b1*m.b3*m.b5*m.b7 + 64*m.b1*m.b3*m.b6*m.b8 + 64
*m.b1*m.b3*m.b7*m.b9 + 64*m.b1*m.b3*m.b8*m.b10 + 64*m.b1*m.b3*m.b9*m.b11 + 64*m.b1*m.b3*m.b10*
m.b12 + 64*m.b1*m.b3*m.b11*m.b13 + 64*m.b1*m.b3*m.b12*m.b14 + 64*m.b1*m.b3*m.b13*m.b15 + 64*m.b1*
m.b3*m.b14*m.b16 + 64*m.b1*m.b3*m.b15*m.b17 + 64*m.b1*m.b3*m.b16*m.b18 + 64*m.b1*m.b3*m.b17*m.b19
+ 64*m.b1*m.b3*m.b18*m.b20 + 64*m.b1*m.b3*m.b19*m.b21 + 64*m.b1*m.b3*m.b20*m.b22 + 64*m.b1*m.b3*
m.b21*m.b23 + 64*m.b1*m.b3*m.b22*m.b24 + 64*m.b1*m.b3*m.b23*m.b25 + 64*m.b1*m.b3*m.b24*m.b26 + 64
*m.b1*m.b3*m.b25*m.b27 + 64*m.b1*m.b3*m.b26*m.b28 + 64*m.b1*m.b3*m.b27*m.b29 + 64*m.b1*m.b3*m.b28
*m.b30 + 64*m.b1*m.b3*m.b29*m.b31 + 64*m.b1*m.b3*m.b30*m.b32 + 64*m.b1*m.b3*m.b31*m.b33 + 64*m.b1
*m.b3*m.b32*m.b34 + 64*m.b1*m.b3*m.b33*m.b35 + 64*m.b1*m.b3*m.b34*m.b36 + 64*m.b1*m.b3*m.b35*
m.b37 + 64*m.b1*m.b3*m.b36*m.b38 + 64*m.b1*m.b3*m.b37*m.b39 + 64*m.b1*m.b3*m.b38*m.b40 + 64*m.b1*
m.b4*m.b5*m.b8 + 64*m.b1*m.b4*m.b6*m.b9 + 64*m.b1*m.b4*m.b7*m.b10 + 64*m.b1*m.b4*m.b8*m.b11 + 64*
m.b1*m.b4*m.b9*m.b12 + 64*m.b1*m.b4*m.b10*m.b13 + 64*m.b1*m.b4*m.b11*m.b14 + 64*m.b1*m.b4*m.b12*
m.b15 + 64*m.b1*m.b4*m.b13*m.b16 + 64*m.b1*m.b4*m.b14*m.b17 + 64*m.b1*m.b4*m.b15*m.b18 + 64*m.b1*
m.b4*m.b16*m.b19 + 64*m.b1*m.b4*m.b17*m.b20 + 64*m.b1*m.b4*m.b18*m.b21 + 64*m.b1*m.b4*m.b19*m.b22
+ 64*m.b1*m.b4*m.b20*m.b23 + 64*m.b1*m.b4*m.b21*m.b24 + 64*m.b1*m.b4*m.b22*m.b25 + 64*m.b1*m.b4*
m.b23*m.b26 + 64*m.b1*m.b4*m.b24*m.b27 + 64*m.b1*m.b4*m.b25*m.b28 + 64*m.b1*m.b4*m.b26*m.b29 + 64
*m.b1*m.b4*m.b27*m.b30 + 64*m.b1*m.b4*m.b28*m.b31 + 64*m.b1*m.b4*m.b29*m.b32 + 64*m.b1*m.b4*m.b30
*m.b33 + 64*m.b1*m.b4*m.b31*m.b34 + 64*m.b1*m.b4*m.b32*m.b35 + 64*m.b1*m.b4*m.b33*m.b36 + 64*m.b1
*m.b4*m.b34*m.b37 + 64*m.b1*m.b4*m.b35*m.b38 + 64*m.b1*m.b4*m.b36*m.b39 + 64*m.b1*m.b4*m.b37*
m.b40 + 64*m.b1*m.b5*m.b6*m.b10 + 64*m.b1*m.b5*m.b7*m.b11 + 64*m.b1*m.b5*m.b8*m.b12 + 64*m.b1*
m.b5*m.b9*m.b13 + 64*m.b1*m.b5*m.b10*m.b14 + 64*m.b1*m.b5*m.b11*m.b15 + 64*m.b1*m.b5*m.b12*m.b16
+ 64*m.b1*m.b5*m.b13*m.b17 + 64*m.b1*m.b5*m.b14*m.b18 + 64*m.b1*m.b5*m.b15*m.b19 + 64*m.b1*m.b5*
m.b16*m.b20 + 64*m.b1*m.b5*m.b17*m.b21 + 64*m.b1*m.b5*m.b18*m.b22 + 64*m.b1*m.b5*m.b19*m.b23 + 64
*m.b1*m.b5*m.b20*m.b24 + 64*m.b1*m.b5*m.b21*m.b25 + 64*m.b1*m.b5*m.b22*m.b26 + 64*m.b1*m.b5*m.b23
*m.b27 + 64*m.b1*m.b5*m.b24*m.b28 + 64*m.b1*m.b5*m.b25*m.b29 + 64*m.b1*m.b5*m.b26*m.b30 + 64*m.b1
*m.b5*m.b27*m.b31 + 64*m.b1*m.b5*m.b28*m.b32 + 64*m.b1*m.b5*m.b29*m.b33 + 64*m.b1*m.b5*m.b30*
m.b34 + 64*m.b1*m.b5*m.b31*m.b35 + 64*m.b1*m.b5*m.b32*m.b36 + 64*m.b1*m.b5*m.b33*m.b37 + 64*m.b1*
m.b5*m.b34*m.b38 + 64*m.b1*m.b5*m.b35*m.b39 + 64*m.b1*m.b5*m.b36*m.b40 + 64*m.b1*m.b6*m.b7*m.b12
+ 64*m.b1*m.b6*m.b8*m.b13 + 64*m.b1*m.b6*m.b9*m.b14 + 64*m.b1*m.b6*m.b10*m.b15 + 64*m.b1*m.b6*
m.b11*m.b16 + 64*m.b1*m.b6*m.b12*m.b17 + 64*m.b1*m.b6*m.b13*m.b18 + 64*m.b1*m.b6*m.b14*m.b19 + 64
*m.b1*m.b6*m.b15*m.b20 + 64*m.b1*m.b6*m.b16*m.b21 + 64*m.b1*m.b6*m.b17*m.b22 + 64*m.b1*m.b6*m.b18
*m.b23 + 64*m.b1*m.b6*m.b19*m.b24 + 64*m.b1*m.b6*m.b20*m.b25 + 64*m.b1*m.b6*m.b21*m.b26 + 64*m.b1
*m.b6*m.b22*m.b27 + 64*m.b1*m.b6*m.b23*m.b28 + 64*m.b1*m.b6*m.b24*m.b29 + 64*m.b1*m.b6*m.b25*
m.b30 + 64*m.b1*m.b6*m.b26*m.b31 + 64*m.b1*m.b6*m.b27*m.b32 + 64*m.b1*m.b6*m.b28*m.b33 + 64*m.b1*
m.b6*m.b29*m.b34 + 64*m.b1*m.b6*m.b30*m.b35 + 64*m.b1*m.b6*m.b31*m.b36 + 64*m.b1*m.b6*m.b32*m.b37
+ 64*m.b1*m.b6*m.b33*m.b38 + 64*m.b1*m.b6*m.b34*m.b39 + 64*m.b1*m.b6*m.b35*m.b40 + 64*m.b1*m.b7*
m.b8*m.b14 + 64*m.b1*m.b7*m.b9*m.b15 + 64*m.b1*m.b7*m.b10*m.b16 + 64*m.b1*m.b7*m.b11*m.b17 + 64*
m.b1*m.b7*m.b12*m.b18 + 64*m.b1*m.b7*m.b13*m.b19 + 64*m.b1*m.b7*m.b14*m.b20 + 64*m.b1*m.b7*m.b15*
m.b21 + 64*m.b1*m.b7*m.b16*m.b22 + 64*m.b1*m.b7*m.b17*m.b23 + 64*m.b1*m.b7*m.b18*m.b24 + 64*m.b1*
m.b7*m.b19*m.b25 + 64*m.b1*m.b7*m.b20*m.b26 + 64*m.b1*m.b7*m.b21*m.b27 + 64*m.b1*m.b7*m.b22*m.b28
+ 64*m.b1*m.b7*m.b23*m.b29 + 64*m.b1*m.b7*m.b24*m.b30 + 64*m.b1*m.b7*m.b25*m.b31 + 64*m.b1*m.b7*
m.b26*m.b32 + 64*m.b1*m.b7*m.b27*m.b33 + 64*m.b1*m.b7*m.b28*m.b34 + 64*m.b1*m.b7*m.b29*m.b35 + 64
*m.b1*m.b7*m.b30*m.b36 + 64*m.b1*m.b7*m.b31*m.b37 + 64*m.b1*m.b7*m.b32*m.b38 + 64*m.b1*m.b7*m.b33
*m.b39 + 64*m.b1*m.b7*m.b34*m.b40 + 64*m.b1*m.b8*m.b9*m.b16 + 64*m.b1*m.b8*m.b10*m.b17 + 64*m.b1*
m.b8*m.b11*m.b18 + 64*m.b1*m.b8*m.b12*m.b19 + 64*m.b1*m.b8*m.b13*m.b20 + 64*m.b1*m.b8*m.b14*m.b21
+ 64*m.b1*m.b8*m.b15*m.b22 + 64*m.b1*m.b8*m.b16*m.b23 + 64*m.b1*m.b8*m.b17*m.b24 + 64*m.b1*m.b8*
m.b18*m.b25 + 64*m.b1*m.b8*m.b19*m.b26 + 64*m.b1*m.b8*m.b20*m.b27 + 64*m.b1*m.b8*m.b21*m.b28 + 64
*m.b1*m.b8*m.b22*m.b29 + 64*m.b1*m.b8*m.b23*m.b30 + 64*m.b1*m.b8*m.b24*m.b31 + 64*m.b1*m.b8*m.b25
*m.b32 + 64*m.b1*m.b8*m.b26*m.b33 + 64*m.b1*m.b8*m.b27*m.b34 + 64*m.b1*m.b8*m.b28*m.b35 + 64*m.b1
*m.b8*m.b29*m.b36 + 64*m.b1*m.b8*m.b30*m.b37 + 64*m.b1*m.b8*m.b31*m.b38 + 64*m.b1*m.b8*m.b32*
m.b39 + 64*m.b1*m.b8*m.b33*m.b40 + 64*m.b1*m.b9*m.b10*m.b18 + 64*m.b1*m.b9*m.b11*m.b19 + 64*m.b1*
m.b9*m.b12*m.b20 + 64*m.b1*m.b9*m.b13*m.b21 + 64*m.b1*m.b9*m.b14*m.b22 + 64*m.b1*m.b9*m.b15*m.b23
+ 64*m.b1*m.b9*m.b16*m.b24 + 64*m.b1*m.b9*m.b17*m.b25 + 64*m.b1*m.b9*m.b18*m.b26 + 64*m.b1*m.b9*
m.b19*m.b27 + 64*m.b1*m.b9*m.b20*m.b28 + 64*m.b1*m.b9*m.b21*m.b29 + 64*m.b1*m.b9*m.b22*m.b30 + 64
*m.b1*m.b9*m.b23*m.b31 + 64*m.b1*m.b9*m.b24*m.b32 + 64*m.b1*m.b9*m.b25*m.b33 + 64*m.b1*m.b9*m.b26
*m.b34 + 64*m.b1*m.b9*m.b27*m.b35 + 64*m.b1*m.b9*m.b28*m.b36 + 64*m.b1*m.b9*m.b29*m.b37 + 64*m.b1
*m.b9*m.b30*m.b38 + 64*m.b1*m.b9*m.b31*m.b39 + 64*m.b1*m.b9*m.b32*m.b40 + 64*m.b1*m.b10*m.b11*
m.b20 + 64*m.b1*m.b10*m.b12*m.b21 + 64*m.b1*m.b10*m.b13*m.b22 + 64*m.b1*m.b10*m.b14*m.b23 + 64*
m.b1*m.b10*m.b15*m.b24 + 64*m.b1*m.b10*m.b16*m.b25 + 64*m.b1*m.b10*m.b17*m.b26 + 64*m.b1*m.b10*
m.b18*m.b27 + 64*m.b1*m.b10*m.b19*m.b28 + 64*m.b1*m.b10*m.b20*m.b29 + 64*m.b1*m.b10*m.b21*m.b30
+ 64*m.b1*m.b10*m.b22*m.b31 + 64*m.b1*m.b10*m.b23*m.b32 + 64*m.b1*m.b10*m.b24*m.b33 + 64*m.b1*
m.b10*m.b25*m.b34 + 64*m.b1*m.b10*m.b26*m.b35 + 64*m.b1*m.b10*m.b27*m.b36 + 64*m.b1*m.b10*m.b28*
m.b37 + 64*m.b1*m.b10*m.b29*m.b38 + 64*m.b1*m.b10*m.b30*m.b39 + 64*m.b1*m.b10*m.b31*m.b40 + 64*
m.b1*m.b11*m.b12*m.b22 + 64*m.b1*m.b11*m.b13*m.b23 + 64*m.b1*m.b11*m.b14*m.b24 + 64*m.b1*m.b11*
m.b15*m.b25 + 64*m.b1*m.b11*m.b16*m.b26 + 64*m.b1*m.b11*m.b17*m.b27 + 64*m.b1*m.b11*m.b18*m.b28
+ 64*m.b1*m.b11*m.b19*m.b29 + 64*m.b1*m.b11*m.b20*m.b30 + 64*m.b1*m.b11*m.b21*m.b31 + 64*m.b1*
m.b11*m.b22*m.b32 + 64*m.b1*m.b11*m.b23*m.b33 + 64*m.b1*m.b11*m.b24*m.b34 + 64*m.b1*m.b11*m.b25*
m.b35 + 64*m.b1*m.b11*m.b26*m.b36 + 64*m.b1*m.b11*m.b27*m.b37 + 64*m.b1*m.b11*m.b28*m.b38 + 64*
m.b1*m.b11*m.b29*m.b39 + 64*m.b1*m.b11*m.b30*m.b40 + 64*m.b1*m.b12*m.b13*m.b24 + 64*m.b1*m.b12*
m.b14*m.b25 + 64*m.b1*m.b12*m.b15*m.b26 + 64*m.b1*m.b12*m.b16*m.b27 + 64*m.b1*m.b12*m.b17*m.b28
+ 64*m.b1*m.b12*m.b18*m.b29 + 64*m.b1*m.b12*m.b19*m.b30 + 64*m.b1*m.b12*m.b20*m.b31 + 64*m.b1*
m.b12*m.b21*m.b32 + 64*m.b1*m.b12*m.b22*m.b33 + 64*m.b1*m.b12*m.b23*m.b34 + 64*m.b1*m.b12*m.b24*
m.b35 + 64*m.b1*m.b12*m.b25*m.b36 + 64*m.b1*m.b12*m.b26*m.b37 + 64*m.b1*m.b12*m.b27*m.b38 + 64*
m.b1*m.b12*m.b28*m.b39 + 64*m.b1*m.b12*m.b29*m.b40 + 64*m.b1*m.b13*m.b14*m.b26 + 64*m.b1*m.b13*
m.b15*m.b27 + 64*m.b1*m.b13*m.b16*m.b28 + 64*m.b1*m.b13*m.b17*m.b29 + 64*m.b1*m.b13*m.b18*m.b30
+ 64*m.b1*m.b13*m.b19*m.b31 + 64*m.b1*m.b13*m.b20*m.b32 + 64*m.b1*m.b13*m.b21*m.b33 + 64*m.b1*
m.b13*m.b22*m.b34 + 64*m.b1*m.b13*m.b23*m.b35 + 64*m.b1*m.b13*m.b24*m.b36 + 64*m.b1*m.b13*m.b25*
m.b37 + 64*m.b1*m.b13*m.b26*m.b38 + 64*m.b1*m.b13*m.b27*m.b39 + 64*m.b1*m.b13*m.b28*m.b40 + 64*
m.b1*m.b14*m.b15*m.b28 + 64*m.b1*m.b14*m.b16*m.b29 + 64*m.b1*m.b14*m.b17*m.b30 + 64*m.b1*m.b14*
m.b18*m.b31 + 64*m.b1*m.b14*m.b19*m.b32 + 64*m.b1*m.b14*m.b20*m.b33 + 64*m.b1*m.b14*m.b21*m.b34
+ 64*m.b1*m.b14*m.b22*m.b35 + 64*m.b1*m.b14*m.b23*m.b36 + 64*m.b1*m.b14*m.b24*m.b37 + 64*m.b1*
m.b14*m.b25*m.b38 + 64*m.b1*m.b14*m.b26*m.b39 + 64*m.b1*m.b14*m.b27*m.b40 + 64*m.b1*m.b15*m.b16*
m.b30 + 64*m.b1*m.b15*m.b17*m.b31 + 64*m.b1*m.b15*m.b18*m.b32 + 64*m.b1*m.b15*m.b19*m.b33 + 64*
m.b1*m.b15*m.b20*m.b34 + 64*m.b1*m.b15*m.b21*m.b35 + 64*m.b1*m.b15*m.b22*m.b36 + 64*m.b1*m.b15*
m.b23*m.b37 + 64*m.b1*m.b15*m.b24*m.b38 + 64*m.b1*m.b15*m.b25*m.b39 + 64*m.b1*m.b15*m.b26*m.b40
+ 64*m.b1*m.b16*m.b17*m.b32 + 64*m.b1*m.b16*m.b18*m.b33 + 64*m.b1*m.b16*m.b19*m.b34 + 64*m.b1*
m.b16*m.b20*m.b35 + 64*m.b1*m.b16*m.b21*m.b36 + 64*m.b1*m.b16*m.b22*m.b37 + 64*m.b1*m.b16*m.b23*
m.b38 + 64*m.b1*m.b16*m.b24*m.b39 + 64*m.b1*m.b16*m.b25*m.b40 + 64*m.b1*m.b17*m.b18*m.b34 + 64*
m.b1*m.b17*m.b19*m.b35 + 64*m.b1*m.b17*m.b20*m.b36 + 64*m.b1*m.b17*m.b21*m.b37 + 64*m.b1*m.b17*
m.b22*m.b38 + 64*m.b1*m.b17*m.b23*m.b39 + 64*m.b1*m.b17*m.b24*m.b40 + 64*m.b1*m.b18*m.b19*m.b36
+ 64*m.b1*m.b18*m.b20*m.b37 + 64*m.b1*m.b18*m.b21*m.b38 + 64*m.b1*m.b18*m.b22*m.b39 + 64*m.b1*
m.b18*m.b23*m.b40 + 64*m.b1*m.b19*m.b20*m.b38 + 64*m.b1*m.b19*m.b21*m.b39 + 64*m.b1*m.b19*m.b22*
m.b40 + 64*m.b1*m.b20*m.b21*m.b40 + 64*m.b2*m.b3*m.b4*m.b5 + 64*m.b2*m.b3*m.b5*m.b6 + 64*m.b2*
m.b3*m.b6*m.b7 + 64*m.b2*m.b3*m.b7*m.b8 + 64*m.b2*m.b3*m.b8*m.b9 + 64*m.b2*m.b3*m.b9*m.b10 + 64*
m.b2*m.b3*m.b10*m.b11 + 64*m.b2*m.b3*m.b11*m.b12 + 64*m.b2*m.b3*m.b12*m.b13 + 64*m.b2*m.b3*m.b13*
m.b14 + 64*m.b2*m.b3*m.b14*m.b15 + 64*m.b2*m.b3*m.b15*m.b16 + 64*m.b2*m.b3*m.b16*m.b17 + 128*m.b2
*m.b3*m.b17*m.b18 + 128*m.b2*m.b3*m.b18*m.b19 + 128*m.b2*m.b3*m.b19*m.b20 + 128*m.b2*m.b3*m.b20*
m.b21 + 128*m.b2*m.b3*m.b21*m.b22 + 128*m.b2*m.b3*m.b22*m.b23 + 128*m.b2*m.b3*m.b23*m.b24 + 128*
m.b2*m.b3*m.b24*m.b25 + 128*m.b2*m.b3*m.b25*m.b26 + 128*m.b2*m.b3*m.b26*m.b27 + 128*m.b2*m.b3*
m.b27*m.b28 + 128*m.b2*m.b3*m.b28*m.b29 + 128*m.b2*m.b3*m.b29*m.b30 + 128*m.b2*m.b3*m.b30*m.b31
+ 128*m.b2*m.b3*m.b31*m.b32 + 128*m.b2*m.b3*m.b32*m.b33 + 128*m.b2*m.b3*m.b33*m.b34 + 128*m.b2*
m.b3*m.b34*m.b35 + 128*m.b2*m.b3*m.b35*m.b36 + 128*m.b2*m.b3*m.b36*m.b37 + 128*m.b2*m.b3*m.b37*
m.b38 + 128*m.b2*m.b3*m.b38*m.b39 + 64*m.b2*m.b3*m.b39*m.b40 + 64*m.b2*m.b4*m.b5*m.b7 + 64*m.b2*
m.b4*m.b6*m.b8 + 64*m.b2*m.b4*m.b7*m.b9 + 64*m.b2*m.b4*m.b8*m.b10 + 64*m.b2*m.b4*m.b9*m.b11 + 64*
m.b2*m.b4*m.b10*m.b12 + 64*m.b2*m.b4*m.b11*m.b13 + 64*m.b2*m.b4*m.b12*m.b14 + 64*m.b2*m.b4*m.b13*
m.b15 + 64*m.b2*m.b4*m.b14*m.b16 + 64*m.b2*m.b4*m.b15*m.b17 + 128*m.b2*m.b4*m.b16*m.b18 + 128*
m.b2*m.b4*m.b17*m.b19 + 128*m.b2*m.b4*m.b18*m.b20 + 128*m.b2*m.b4*m.b19*m.b21 + 128*m.b2*m.b4*
m.b20*m.b22 + 128*m.b2*m.b4*m.b21*m.b23 + 128*m.b2*m.b4*m.b22*m.b24 + 128*m.b2*m.b4*m.b23*m.b25
+ 128*m.b2*m.b4*m.b24*m.b26 + 128*m.b2*m.b4*m.b25*m.b27 + 128*m.b2*m.b4*m.b26*m.b28 + 128*m.b2*
m.b4*m.b27*m.b29 + 128*m.b2*m.b4*m.b28*m.b30 + 128*m.b2*m.b4*m.b29*m.b31 + 128*m.b2*m.b4*m.b30*
m.b32 + 128*m.b2*m.b4*m.b31*m.b33 + 128*m.b2*m.b4*m.b32*m.b34 + 128*m.b2*m.b4*m.b33*m.b35 + 128*
m.b2*m.b4*m.b34*m.b36 + 128*m.b2*m.b4*m.b35*m.b37 + 128*m.b2*m.b4*m.b36*m.b38 + 128*m.b2*m.b4*
m.b37*m.b39 + 64*m.b2*m.b4*m.b38*m.b40 + 64*m.b2*m.b5*m.b6*m.b9 + 64*m.b2*m.b5*m.b7*m.b10 + 64*
m.b2*m.b5*m.b8*m.b11 + 64*m.b2*m.b5*m.b9*m.b12 + 64*m.b2*m.b5*m.b10*m.b13 + 64*m.b2*m.b5*m.b11*
m.b14 + 64*m.b2*m.b5*m.b12*m.b15 + 64*m.b2*m.b5*m.b13*m.b16 + 64*m.b2*m.b5*m.b14*m.b17 + 128*m.b2
*m.b5*m.b15*m.b18 + 128*m.b2*m.b5*m.b16*m.b19 + 128*m.b2*m.b5*m.b17*m.b20 + 128*m.b2*m.b5*m.b18*
m.b21 + 128*m.b2*m.b5*m.b19*m.b22 + 128*m.b2*m.b5*m.b20*m.b23 + 128*m.b2*m.b5*m.b21*m.b24 + 128*
m.b2*m.b5*m.b22*m.b25 + 128*m.b2*m.b5*m.b23*m.b26 + 128*m.b2*m.b5*m.b24*m.b27 + 128*m.b2*m.b5*
m.b25*m.b28 + 128*m.b2*m.b5*m.b26*m.b29 + 128*m.b2*m.b5*m.b27*m.b30 + 128*m.b2*m.b5*m.b28*m.b31
+ 128*m.b2*m.b5*m.b29*m.b32 + 128*m.b2*m.b5*m.b30*m.b33 + 128*m.b2*m.b5*m.b31*m.b34 + 128*m.b2*
m.b5*m.b32*m.b35 + 128*m.b2*m.b5*m.b33*m.b36 + 128*m.b2*m.b5*m.b34*m.b37 + 128*m.b2*m.b5*m.b35*
m.b38 + 128*m.b2*m.b5*m.b36*m.b39 + 64*m.b2*m.b5*m.b37*m.b40 + 64*m.b2*m.b6*m.b7*m.b11 + 64*m.b2*
m.b6*m.b8*m.b12 + 64*m.b2*m.b6*m.b9*m.b13 + 64*m.b2*m.b6*m.b10*m.b14 + 64*m.b2*m.b6*m.b11*m.b15
+ 64*m.b2*m.b6*m.b12*m.b16 + 64*m.b2*m.b6*m.b13*m.b17 + 128*m.b2*m.b6*m.b14*m.b18 + 128*m.b2*
m.b6*m.b15*m.b19 + 128*m.b2*m.b6*m.b16*m.b20 + 128*m.b2*m.b6*m.b17*m.b21 + 128*m.b2*m.b6*m.b18*
m.b22 + 128*m.b2*m.b6*m.b19*m.b23 + 128*m.b2*m.b6*m.b20*m.b24 + 128*m.b2*m.b6*m.b21*m.b25 + 128*
m.b2*m.b6*m.b22*m.b26 + 128*m.b2*m.b6*m.b23*m.b27 + 128*m.b2*m.b6*m.b24*m.b28 + 128*m.b2*m.b6*
m.b25*m.b29 + 128*m.b2*m.b6*m.b26*m.b30 + 128*m.b2*m.b6*m.b27*m.b31 + 128*m.b2*m.b6*m.b28*m.b32
+ 128*m.b2*m.b6*m.b29*m.b33 + 128*m.b2*m.b6*m.b30*m.b34 + 128*m.b2*m.b6*m.b31*m.b35 + 128*m.b2*
m.b6*m.b32*m.b36 + 128*m.b2*m.b6*m.b33*m.b37 + 128*m.b2*m.b6*m.b34*m.b38 + 128*m.b2*m.b6*m.b35*
m.b39 + 64*m.b2*m.b6*m.b36*m.b40 + 64*m.b2*m.b7*m.b8*m.b13 + 64*m.b2*m.b7*m.b9*m.b14 + 64*m.b2*
m.b7*m.b10*m.b15 + 64*m.b2*m.b7*m.b11*m.b16 + 64*m.b2*m.b7*m.b12*m.b17 + 128*m.b2*m.b7*m.b13*
m.b18 + 128*m.b2*m.b7*m.b14*m.b19 + 128*m.b2*m.b7*m.b15*m.b20 + 128*m.b2*m.b7*m.b16*m.b21 + 128*
m.b2*m.b7*m.b17*m.b22 + 128*m.b2*m.b7*m.b18*m.b23 + 128*m.b2*m.b7*m.b19*m.b24 + 128*m.b2*m.b7*
m.b20*m.b25 + 128*m.b2*m.b7*m.b21*m.b26 + 128*m.b2*m.b7*m.b22*m.b27 + 128*m.b2*m.b7*m.b23*m.b28
+ 128*m.b2*m.b7*m.b24*m.b29 + 128*m.b2*m.b7*m.b25*m.b30 + 128*m.b2*m.b7*m.b26*m.b31 + 128*m.b2*
m.b7*m.b27*m.b32 + 128*m.b2*m.b7*m.b28*m.b33 + 128*m.b2*m.b7*m.b29*m.b34 + 128*m.b2*m.b7*m.b30*
m.b35 + 128*m.b2*m.b7*m.b31*m.b36 + 128*m.b2*m.b7*m.b32*m.b37 + 128*m.b2*m.b7*m.b33*m.b38 + 128*
m.b2*m.b7*m.b34*m.b39 + 64*m.b2*m.b7*m.b35*m.b40 + 64*m.b2*m.b8*m.b9*m.b15 + 64*m.b2*m.b8*m.b10*
m.b16 + 64*m.b2*m.b8*m.b11*m.b17 + 128*m.b2*m.b8*m.b12*m.b18 + 128*m.b2*m.b8*m.b13*m.b19 + 128*
m.b2*m.b8*m.b14*m.b20 + 128*m.b2*m.b8*m.b15*m.b21 + 128*m.b2*m.b8*m.b16*m.b22 + 128*m.b2*m.b8*
m.b17*m.b23 + 128*m.b2*m.b8*m.b18*m.b24 + 128*m.b2*m.b8*m.b19*m.b25 + 128*m.b2*m.b8*m.b20*m.b26
+ 128*m.b2*m.b8*m.b21*m.b27 + 128*m.b2*m.b8*m.b22*m.b28 + 128*m.b2*m.b8*m.b23*m.b29 + 128*m.b2*
m.b8*m.b24*m.b30 + 128*m.b2*m.b8*m.b25*m.b31 + 128*m.b2*m.b8*m.b26*m.b32 + 128*m.b2*m.b8*m.b27*
m.b33 + 128*m.b2*m.b8*m.b28*m.b34 + 128*m.b2*m.b8*m.b29*m.b35 + 128*m.b2*m.b8*m.b30*m.b36 + 128*
m.b2*m.b8*m.b31*m.b37 + 128*m.b2*m.b8*m.b32*m.b38 + 128*m.b2*m.b8*m.b33*m.b39 + 64*m.b2*m.b8*
m.b34*m.b40 + 64*m.b2*m.b9*m.b10*m.b17 + 128*m.b2*m.b9*m.b11*m.b18 + 128*m.b2*m.b9*m.b12*m.b19 +
128*m.b2*m.b9*m.b13*m.b20 + 128*m.b2*m.b9*m.b14*m.b21 + 128*m.b2*m.b9*m.b15*m.b22 + 128*m.b2*m.b9
*m.b16*m.b23 + 128*m.b2*m.b9*m.b17*m.b24 + 128*m.b2*m.b9*m.b18*m.b25 + 128*m.b2*m.b9*m.b19*m.b26
+ 128*m.b2*m.b9*m.b20*m.b27 + 128*m.b2*m.b9*m.b21*m.b28 + 128*m.b2*m.b9*m.b22*m.b29 + 128*m.b2*
m.b9*m.b23*m.b30 + 128*m.b2*m.b9*m.b24*m.b31 + 128*m.b2*m.b9*m.b25*m.b32 + 128*m.b2*m.b9*m.b26*
m.b33 + 128*m.b2*m.b9*m.b27*m.b34 + 128*m.b2*m.b9*m.b28*m.b35 + 128*m.b2*m.b9*m.b29*m.b36 + 128*
m.b2*m.b9*m.b30*m.b37 + 128*m.b2*m.b9*m.b31*m.b38 + 128*m.b2*m.b9*m.b32*m.b39 + 64*m.b2*m.b9*
m.b33*m.b40 + 128*m.b2*m.b10*m.b11*m.b19 + 128*m.b2*m.b10*m.b12*m.b20 + 128*m.b2*m.b10*m.b13*
m.b21 + 128*m.b2*m.b10*m.b14*m.b22 + 128*m.b2*m.b10*m.b15*m.b23 + 128*m.b2*m.b10*m.b16*m.b24 +
128*m.b2*m.b10*m.b17*m.b25 + 128*m.b2*m.b10*m.b18*m.b26 + 128*m.b2*m.b10*m.b19*m.b27 + 128*m.b2*
m.b10*m.b20*m.b28 + 128*m.b2*m.b10*m.b21*m.b29 + 128*m.b2*m.b10*m.b22*m.b30 + 128*m.b2*m.b10*
m.b23*m.b31 + 128*m.b2*m.b10*m.b24*m.b32 + 128*m.b2*m.b10*m.b25*m.b33 + 128*m.b2*m.b10*m.b26*
m.b34 + 128*m.b2*m.b10*m.b27*m.b35 + 128*m.b2*m.b10*m.b28*m.b36 + 128*m.b2*m.b10*m.b29*m.b37 +
128*m.b2*m.b10*m.b30*m.b38 + 128*m.b2*m.b10*m.b31*m.b39 + 64*m.b2*m.b10*m.b32*m.b40 + 128*m.b2*
m.b11*m.b12*m.b21 + 128*m.b2*m.b11*m.b13*m.b22 + 128*m.b2*m.b11*m.b14*m.b23 + 128*m.b2*m.b11*
m.b15*m.b24 + 128*m.b2*m.b11*m.b16*m.b25 + 128*m.b2*m.b11*m.b17*m.b26 + 128*m.b2*m.b11*m.b18*
m.b27 + 128*m.b2*m.b11*m.b19*m.b28 + 128*m.b2*m.b11*m.b20*m.b29 + 128*m.b2*m.b11*m.b21*m.b30 +
128*m.b2*m.b11*m.b22*m.b31 + 128*m.b2*m.b11*m.b23*m.b32 + 128*m.b2*m.b11*m.b24*m.b33 + 128*m.b2*
m.b11*m.b25*m.b34 + 128*m.b2*m.b11*m.b26*m.b35 + 128*m.b2*m.b11*m.b27*m.b36 + 128*m.b2*m.b11*
m.b28*m.b37 + 128*m.b2*m.b11*m.b29*m.b38 + 128*m.b2*m.b11*m.b30*m.b39 + 64*m.b2*m.b11*m.b31*m.b40
+ 128*m.b2*m.b12*m.b13*m.b23 + 128*m.b2*m.b12*m.b14*m.b24 + 128*m.b2*m.b12*m.b15*m.b25 + 128*
m.b2*m.b12*m.b16*m.b26 + 128*m.b2*m.b12*m.b17*m.b27 + 128*m.b2*m.b12*m.b18*m.b28 + 128*m.b2*m.b12
*m.b19*m.b29 + 128*m.b2*m.b12*m.b20*m.b30 + 128*m.b2*m.b12*m.b21*m.b31 + 128*m.b2*m.b12*m.b22*
m.b32 + 128*m.b2*m.b12*m.b23*m.b33 + 128*m.b2*m.b12*m.b24*m.b34 + 128*m.b2*m.b12*m.b25*m.b35 +
128*m.b2*m.b12*m.b26*m.b36 + 128*m.b2*m.b12*m.b27*m.b37 + 128*m.b2*m.b12*m.b28*m.b38 + 128*m.b2*
m.b12*m.b29*m.b39 + 64*m.b2*m.b12*m.b30*m.b40 + 128*m.b2*m.b13*m.b14*m.b25 + 128*m.b2*m.b13*m.b15
*m.b26 + 128*m.b2*m.b13*m.b16*m.b27 + 128*m.b2*m.b13*m.b17*m.b28 + 128*m.b2*m.b13*m.b18*m.b29 +
128*m.b2*m.b13*m.b19*m.b30 + 128*m.b2*m.b13*m.b20*m.b31 + 128*m.b2*m.b13*m.b21*m.b32 + 128*m.b2*
m.b13*m.b22*m.b33 + 128*m.b2*m.b13*m.b23*m.b34 + 128*m.b2*m.b13*m.b24*m.b35 + 128*m.b2*m.b13*
m.b25*m.b36 + 128*m.b2*m.b13*m.b26*m.b37 + 128*m.b2*m.b13*m.b27*m.b38 + 128*m.b2*m.b13*m.b28*
m.b39 + 64*m.b2*m.b13*m.b29*m.b40 + 128*m.b2*m.b14*m.b15*m.b27 + 128*m.b2*m.b14*m.b16*m.b28 + 128
*m.b2*m.b14*m.b17*m.b29 + 128*m.b2*m.b14*m.b18*m.b30 + 128*m.b2*m.b14*m.b19*m.b31 + 128*m.b2*
m.b14*m.b20*m.b32 + 128*m.b2*m.b14*m.b21*m.b33 + 128*m.b2*m.b14*m.b22*m.b34 + 128*m.b2*m.b14*
m.b23*m.b35 + 128*m.b2*m.b14*m.b24*m.b36 + 128*m.b2*m.b14*m.b25*m.b37 + 128*m.b2*m.b14*m.b26*
m.b38 + 128*m.b2*m.b14*m.b27*m.b39 + 64*m.b2*m.b14*m.b28*m.b40 + 128*m.b2*m.b15*m.b16*m.b29 + 128
*m.b2*m.b15*m.b17*m.b30 + 128*m.b2*m.b15*m.b18*m.b31 + 128*m.b2*m.b15*m.b19*m.b32 + 128*m.b2*
m.b15*m.b20*m.b33 + 128*m.b2*m.b15*m.b21*m.b34 + 128*m.b2*m.b15*m.b22*m.b35 + 128*m.b2*m.b15*
m.b23*m.b36 + 128*m.b2*m.b15*m.b24*m.b37 + 128*m.b2*m.b15*m.b25*m.b38 + 128*m.b2*m.b15*m.b26*
m.b39 + 64*m.b2*m.b15*m.b27*m.b40 + 128*m.b2*m.b16*m.b17*m.b31 + 128*m.b2*m.b16*m.b18*m.b32 + 128
*m.b2*m.b16*m.b19*m.b33 + 128*m.b2*m.b16*m.b20*m.b34 + 128*m.b2*m.b16*m.b21*m.b35 + 128*m.b2*
m.b16*m.b22*m.b36 + 128*m.b2*m.b16*m.b23*m.b37 + 128*m.b2*m.b16*m.b24*m.b38 + 128*m.b2*m.b16*
m.b25*m.b39 + 64*m.b2*m.b16*m.b26*m.b40 + 128*m.b2*m.b17*m.b18*m.b33 + 128*m.b2*m.b17*m.b19*m.b34
+ 128*m.b2*m.b17*m.b20*m.b35 + 128*m.b2*m.b17*m.b21*m.b36 + 128*m.b2*m.b17*m.b22*m.b37 + 128*
m.b2*m.b17*m.b23*m.b38 + 128*m.b2*m.b17*m.b24*m.b39 + 64*m.b2*m.b17*m.b25*m.b40 + 128*m.b2*m.b18*
m.b19*m.b35 + 128*m.b2*m.b18*m.b20*m.b36 + 128*m.b2*m.b18*m.b21*m.b37 + 128*m.b2*m.b18*m.b22*
m.b38 + 128*m.b2*m.b18*m.b23*m.b39 + 64*m.b2*m.b18*m.b24*m.b40 + 128*m.b2*m.b19*m.b20*m.b37 + 128
*m.b2*m.b19*m.b21*m.b38 + 128*m.b2*m.b19*m.b22*m.b39 + 64*m.b2*m.b19*m.b23*m.b40 + 128*m.b2*m.b20
*m.b21*m.b39 + 64*m.b2*m.b20*m.b22*m.b40 + 64*m.b3*m.b4*m.b5*m.b6 + 64*m.b3*m.b4*m.b6*m.b7 + 64*
m.b3*m.b4*m.b7*m.b8 + 64*m.b3*m.b4*m.b8*m.b9 + 64*m.b3*m.b4*m.b9*m.b10 + 64*m.b3*m.b4*m.b10*m.b11
+ 64*m.b3*m.b4*m.b11*m.b12 + 64*m.b3*m.b4*m.b12*m.b13 + 64*m.b3*m.b4*m.b13*m.b14 + 64*m.b3*m.b4*
m.b14*m.b15 + 64*m.b3*m.b4*m.b15*m.b16 + 64*m.b3*m.b4*m.b16*m.b17 + 64*m.b3*m.b4*m.b17*m.b18 +
192*m.b3*m.b4*m.b18*m.b19 + 192*m.b3*m.b4*m.b19*m.b20 + 192*m.b3*m.b4*m.b20*m.b21 + 192*m.b3*m.b4
*m.b21*m.b22 + 192*m.b3*m.b4*m.b22*m.b23 + 192*m.b3*m.b4*m.b23*m.b24 + 192*m.b3*m.b4*m.b24*m.b25
+ 192*m.b3*m.b4*m.b25*m.b26 + 192*m.b3*m.b4*m.b26*m.b27 + 192*m.b3*m.b4*m.b27*m.b28 + 192*m.b3*
m.b4*m.b28*m.b29 + 192*m.b3*m.b4*m.b29*m.b30 + 192*m.b3*m.b4*m.b30*m.b31 + 192*m.b3*m.b4*m.b31*
m.b32 + 192*m.b3*m.b4*m.b32*m.b33 + 192*m.b3*m.b4*m.b33*m.b34 + 192*m.b3*m.b4*m.b34*m.b35 + 192*
m.b3*m.b4*m.b35*m.b36 + 192*m.b3*m.b4*m.b36*m.b37 + 192*m.b3*m.b4*m.b37*m.b38 + 128*m.b3*m.b4*
m.b38*m.b39 + 64*m.b3*m.b4*m.b39*m.b40 + 64*m.b3*m.b5*m.b6*m.b8 + 64*m.b3*m.b5*m.b7*m.b9 + 64*
m.b3*m.b5*m.b8*m.b10 + 64*m.b3*m.b5*m.b9*m.b11 + 64*m.b3*m.b5*m.b10*m.b12 + 64*m.b3*m.b5*m.b11*
m.b13 + 64*m.b3*m.b5*m.b12*m.b14 + 64*m.b3*m.b5*m.b13*m.b15 + 64*m.b3*m.b5*m.b14*m.b16 + 64*m.b3*
m.b5*m.b15*m.b17 + 64*m.b3*m.b5*m.b16*m.b18 + 192*m.b3*m.b5*m.b17*m.b19 + 192*m.b3*m.b5*m.b18*
m.b20 + 192*m.b3*m.b5*m.b19*m.b21 + 192*m.b3*m.b5*m.b20*m.b22 + 192*m.b3*m.b5*m.b21*m.b23 + 192*
m.b3*m.b5*m.b22*m.b24 + 192*m.b3*m.b5*m.b23*m.b25 + 192*m.b3*m.b5*m.b24*m.b26 + 192*m.b3*m.b5*
m.b25*m.b27 + 192*m.b3*m.b5*m.b26*m.b28 + 192*m.b3*m.b5*m.b27*m.b29 + 192*m.b3*m.b5*m.b28*m.b30
+ 192*m.b3*m.b5*m.b29*m.b31 + 192*m.b3*m.b5*m.b30*m.b32 + 192*m.b3*m.b5*m.b31*m.b33 + 192*m.b3*
m.b5*m.b32*m.b34 + 192*m.b3*m.b5*m.b33*m.b35 + 192*m.b3*m.b5*m.b34*m.b36 + 192*m.b3*m.b5*m.b35*
m.b37 + 192*m.b3*m.b5*m.b36*m.b38 + 128*m.b3*m.b5*m.b37*m.b39 + 64*m.b3*m.b5*m.b38*m.b40 + 64*
m.b3*m.b6*m.b7*m.b10 + 64*m.b3*m.b6*m.b8*m.b11 + 64*m.b3*m.b6*m.b9*m.b12 + 64*m.b3*m.b6*m.b10*
m.b13 + 64*m.b3*m.b6*m.b11*m.b14 + 64*m.b3*m.b6*m.b12*m.b15 + 64*m.b3*m.b6*m.b13*m.b16 + 64*m.b3*
m.b6*m.b14*m.b17 + 64*m.b3*m.b6*m.b15*m.b18 + 192*m.b3*m.b6*m.b16*m.b19 + 192*m.b3*m.b6*m.b17*
m.b20 + 192*m.b3*m.b6*m.b18*m.b21 + 192*m.b3*m.b6*m.b19*m.b22 + 192*m.b3*m.b6*m.b20*m.b23 + 192*
m.b3*m.b6*m.b21*m.b24 + 192*m.b3*m.b6*m.b22*m.b25 + 192*m.b3*m.b6*m.b23*m.b26 + 192*m.b3*m.b6*
m.b24*m.b27 + 192*m.b3*m.b6*m.b25*m.b28 + 192*m.b3*m.b6*m.b26*m.b29 + 192*m.b3*m.b6*m.b27*m.b30
+ 192*m.b3*m.b6*m.b28*m.b31 + 192*m.b3*m.b6*m.b29*m.b32 + 192*m.b3*m.b6*m.b30*m.b33 + 192*m.b3*
m.b6*m.b31*m.b34 + 192*m.b3*m.b6*m.b32*m.b35 + 192*m.b3*m.b6*m.b33*m.b36 + 192*m.b3*m.b6*m.b34*
m.b37 + 192*m.b3*m.b6*m.b35*m.b38 + 128*m.b3*m.b6*m.b36*m.b39 + 64*m.b3*m.b6*m.b37*m.b40 + 64*
m.b3*m.b7*m.b8*m.b12 + 64*m.b3*m.b7*m.b9*m.b13 + 64*m.b3*m.b7*m.b10*m.b14 + 64*m.b3*m.b7*m.b11*
m.b15 + 64*m.b3*m.b7*m.b12*m.b16 + 64*m.b3*m.b7*m.b13*m.b17 + 64*m.b3*m.b7*m.b14*m.b18 + 192*m.b3
*m.b7*m.b15*m.b19 + 192*m.b3*m.b7*m.b16*m.b20 + 192*m.b3*m.b7*m.b17*m.b21 + 192*m.b3*m.b7*m.b18*
m.b22 + 192*m.b3*m.b7*m.b19*m.b23 + 192*m.b3*m.b7*m.b20*m.b24 + 192*m.b3*m.b7*m.b21*m.b25 + 192*
m.b3*m.b7*m.b22*m.b26 + 192*m.b3*m.b7*m.b23*m.b27 + 192*m.b3*m.b7*m.b24*m.b28 + 192*m.b3*m.b7*
m.b25*m.b29 + 192*m.b3*m.b7*m.b26*m.b30 + 192*m.b3*m.b7*m.b27*m.b31 + 192*m.b3*m.b7*m.b28*m.b32
+ 192*m.b3*m.b7*m.b29*m.b33 + 192*m.b3*m.b7*m.b30*m.b34 + 192*m.b3*m.b7*m.b31*m.b35 + 192*m.b3*
m.b7*m.b32*m.b36 + 192*m.b3*m.b7*m.b33*m.b37 + 192*m.b3*m.b7*m.b34*m.b38 + 128*m.b3*m.b7*m.b35*
m.b39 + 64*m.b3*m.b7*m.b36*m.b40 + 64*m.b3*m.b8*m.b9*m.b14 + 64*m.b3*m.b8*m.b10*m.b15 + 64*m.b3*
m.b8*m.b11*m.b16 + 64*m.b3*m.b8*m.b12*m.b17 + 64*m.b3*m.b8*m.b13*m.b18 + 192*m.b3*m.b8*m.b14*
m.b19 + 192*m.b3*m.b8*m.b15*m.b20 + 192*m.b3*m.b8*m.b16*m.b21 + 192*m.b3*m.b8*m.b17*m.b22 + 192*
m.b3*m.b8*m.b18*m.b23 + 192*m.b3*m.b8*m.b19*m.b24 + 192*m.b3*m.b8*m.b20*m.b25 + 192*m.b3*m.b8*
m.b21*m.b26 + 192*m.b3*m.b8*m.b22*m.b27 + 192*m.b3*m.b8*m.b23*m.b28 + 192*m.b3*m.b8*m.b24*m.b29
+ 192*m.b3*m.b8*m.b25*m.b30 + 192*m.b3*m.b8*m.b26*m.b31 + 192*m.b3*m.b8*m.b27*m.b32 + 192*m.b3*
m.b8*m.b28*m.b33 + 192*m.b3*m.b8*m.b29*m.b34 + 192*m.b3*m.b8*m.b30*m.b35 + 192*m.b3*m.b8*m.b31*
m.b36 + 192*m.b3*m.b8*m.b32*m.b37 + 192*m.b3*m.b8*m.b33*m.b38 + 128*m.b3*m.b8*m.b34*m.b39 + 64*
m.b3*m.b8*m.b35*m.b40 + 64*m.b3*m.b9*m.b10*m.b16 + 64*m.b3*m.b9*m.b11*m.b17 + 64*m.b3*m.b9*m.b12*
m.b18 + 192*m.b3*m.b9*m.b13*m.b19 + 192*m.b3*m.b9*m.b14*m.b20 + 192*m.b3*m.b9*m.b15*m.b21 + 192*
m.b3*m.b9*m.b16*m.b22 + 192*m.b3*m.b9*m.b17*m.b23 + 192*m.b3*m.b9*m.b18*m.b24 + 192*m.b3*m.b9*
m.b19*m.b25 + 192*m.b3*m.b9*m.b20*m.b26 + 192*m.b3*m.b9*m.b21*m.b27 + 192*m.b3*m.b9*m.b22*m.b28
+ 192*m.b3*m.b9*m.b23*m.b29 + 192*m.b3*m.b9*m.b24*m.b30 + 192*m.b3*m.b9*m.b25*m.b31 + 192*m.b3*
m.b9*m.b26*m.b32 + 192*m.b3*m.b9*m.b27*m.b33 + 192*m.b3*m.b9*m.b28*m.b34 + 192*m.b3*m.b9*m.b29*
m.b35 + 192*m.b3*m.b9*m.b30*m.b36 + 192*m.b3*m.b9*m.b31*m.b37 + 192*m.b3*m.b9*m.b32*m.b38 + 128*
m.b3*m.b9*m.b33*m.b39 + 64*m.b3*m.b9*m.b34*m.b40 + 64*m.b3*m.b10*m.b11*m.b18 + 192*m.b3*m.b10*
m.b12*m.b19 + 192*m.b3*m.b10*m.b13*m.b20 + 192*m.b3*m.b10*m.b14*m.b21 + 192*m.b3*m.b10*m.b15*
m.b22 + 192*m.b3*m.b10*m.b16*m.b23 + 192*m.b3*m.b10*m.b17*m.b24 + 192*m.b3*m.b10*m.b18*m.b25 +
192*m.b3*m.b10*m.b19*m.b26 + 192*m.b3*m.b10*m.b20*m.b27 + 192*m.b3*m.b10*m.b21*m.b28 + 192*m.b3*
m.b10*m.b22*m.b29 + 192*m.b3*m.b10*m.b23*m.b30 + 192*m.b3*m.b10*m.b24*m.b31 + 192*m.b3*m.b10*
m.b25*m.b32 + 192*m.b3*m.b10*m.b26*m.b33 + 192*m.b3*m.b10*m.b27*m.b34 + 192*m.b3*m.b10*m.b28*
m.b35 + 192*m.b3*m.b10*m.b29*m.b36 + 192*m.b3*m.b10*m.b30*m.b37 + 192*m.b3*m.b10*m.b31*m.b38 +
128*m.b3*m.b10*m.b32*m.b39 + 64*m.b3*m.b10*m.b33*m.b40 + 192*m.b3*m.b11*m.b12*m.b20 + 192*m.b3*
m.b11*m.b13*m.b21 + 192*m.b3*m.b11*m.b14*m.b22 + 192*m.b3*m.b11*m.b15*m.b23 + 192*m.b3*m.b11*
m.b16*m.b24 + 192*m.b3*m.b11*m.b17*m.b25 + 192*m.b3*m.b11*m.b18*m.b26 + 192*m.b3*m.b11*m.b19*
m.b27 + 192*m.b3*m.b11*m.b20*m.b28 + 192*m.b3*m.b11*m.b21*m.b29 + 192*m.b3*m.b11*m.b22*m.b30 +
192*m.b3*m.b11*m.b23*m.b31 + 192*m.b3*m.b11*m.b24*m.b32 + 192*m.b3*m.b11*m.b25*m.b33 + 192*m.b3*
m.b11*m.b26*m.b34 + 192*m.b3*m.b11*m.b27*m.b35 + 192*m.b3*m.b11*m.b28*m.b36 + 192*m.b3*m.b11*
m.b29*m.b37 + 192*m.b3*m.b11*m.b30*m.b38 + 128*m.b3*m.b11*m.b31*m.b39 + 64*m.b3*m.b11*m.b32*m.b40
+ 192*m.b3*m.b12*m.b13*m.b22 + 192*m.b3*m.b12*m.b14*m.b23 + 192*m.b3*m.b12*m.b15*m.b24 + 192*
m.b3*m.b12*m.b16*m.b25 + 192*m.b3*m.b12*m.b17*m.b26 + 192*m.b3*m.b12*m.b18*m.b27 + 192*m.b3*m.b12
*m.b19*m.b28 + 192*m.b3*m.b12*m.b20*m.b29 + 192*m.b3*m.b12*m.b21*m.b30 + 192*m.b3*m.b12*m.b22*
m.b31 + 192*m.b3*m.b12*m.b23*m.b32 + 192*m.b3*m.b12*m.b24*m.b33 + 192*m.b3*m.b12*m.b25*m.b34 +
192*m.b3*m.b12*m.b26*m.b35 + 192*m.b3*m.b12*m.b27*m.b36 + 192*m.b3*m.b12*m.b28*m.b37 + 192*m.b3*
m.b12*m.b29*m.b38 + 128*m.b3*m.b12*m.b30*m.b39 + 64*m.b3*m.b12*m.b31*m.b40 + 192*m.b3*m.b13*m.b14
*m.b24 + 192*m.b3*m.b13*m.b15*m.b25 + 192*m.b3*m.b13*m.b16*m.b26 + 192*m.b3*m.b13*m.b17*m.b27 +
192*m.b3*m.b13*m.b18*m.b28 + 192*m.b3*m.b13*m.b19*m.b29 + 192*m.b3*m.b13*m.b20*m.b30 + 192*m.b3*
m.b13*m.b21*m.b31 + 192*m.b3*m.b13*m.b22*m.b32 + 192*m.b3*m.b13*m.b23*m.b33 + 192*m.b3*m.b13*
m.b24*m.b34 + 192*m.b3*m.b13*m.b25*m.b35 + 192*m.b3*m.b13*m.b26*m.b36 + 192*m.b3*m.b13*m.b27*
m.b37 + 192*m.b3*m.b13*m.b28*m.b38 + 128*m.b3*m.b13*m.b29*m.b39 + 64*m.b3*m.b13*m.b30*m.b40 + 192
*m.b3*m.b14*m.b15*m.b26 + 192*m.b3*m.b14*m.b16*m.b27 + 192*m.b3*m.b14*m.b17*m.b28 + 192*m.b3*
m.b14*m.b18*m.b29 + 192*m.b3*m.b14*m.b19*m.b30 + 192*m.b3*m.b14*m.b20*m.b31 + 192*m.b3*m.b14*
m.b21*m.b32 + 192*m.b3*m.b14*m.b22*m.b33 + 192*m.b3*m.b14*m.b23*m.b34 + 192*m.b3*m.b14*m.b24*
m.b35 + 192*m.b3*m.b14*m.b25*m.b36 + 192*m.b3*m.b14*m.b26*m.b37 + 192*m.b3*m.b14*m.b27*m.b38 +
128*m.b3*m.b14*m.b28*m.b39 + 64*m.b3*m.b14*m.b29*m.b40 + 192*m.b3*m.b15*m.b16*m.b28 + 192*m.b3*
m.b15*m.b17*m.b29 + 192*m.b3*m.b15*m.b18*m.b30 + 192*m.b3*m.b15*m.b19*m.b31 + 192*m.b3*m.b15*
m.b20*m.b32 + 192*m.b3*m.b15*m.b21*m.b33 + 192*m.b3*m.b15*m.b22*m.b34 + 192*m.b3*m.b15*m.b23*
m.b35 + 192*m.b3*m.b15*m.b24*m.b36 + 192*m.b3*m.b15*m.b25*m.b37 + 192*m.b3*m.b15*m.b26*m.b38 +
128*m.b3*m.b15*m.b27*m.b39 + 64*m.b3*m.b15*m.b28*m.b40 + 192*m.b3*m.b16*m.b17*m.b30 + 192*m.b3*
m.b16*m.b18*m.b31 + 192*m.b3*m.b16*m.b19*m.b32 + 192*m.b3*m.b16*m.b20*m.b33 + 192*m.b3*m.b16*
m.b21*m.b34 + 192*m.b3*m.b16*m.b22*m.b35 + 192*m.b3*m.b16*m.b23*m.b36 + 192*m.b3*m.b16*m.b24*
m.b37 + 192*m.b3*m.b16*m.b25*m.b38 + 128*m.b3*m.b16*m.b26*m.b39 + 64*m.b3*m.b16*m.b27*m.b40 + 192
*m.b3*m.b17*m.b18*m.b32 + 192*m.b3*m.b17*m.b19*m.b33 + 192*m.b3*m.b17*m.b20*m.b34 + 192*m.b3*
m.b17*m.b21*m.b35 + 192*m.b3*m.b17*m.b22*m.b36 + 192*m.b3*m.b17*m.b23*m.b37 + 192*m.b3*m.b17*
m.b24*m.b38 + 128*m.b3*m.b17*m.b25*m.b39 + 64*m.b3*m.b17*m.b26*m.b40 + 192*m.b3*m.b18*m.b19*m.b34
+ 192*m.b3*m.b18*m.b20*m.b35 + 192*m.b3*m.b18*m.b21*m.b36 + 192*m.b3*m.b18*m.b22*m.b37 + 192*
m.b3*m.b18*m.b23*m.b38 + 128*m.b3*m.b18*m.b24*m.b39 + 64*m.b3*m.b18*m.b25*m.b40 + 192*m.b3*m.b19*
m.b20*m.b36 + 192*m.b3*m.b19*m.b21*m.b37 + 192*m.b3*m.b19*m.b22*m.b38 + 128*m.b3*m.b19*m.b23*
m.b39 + 64*m.b3*m.b19*m.b24*m.b40 + 192*m.b3*m.b20*m.b21*m.b38 + 128*m.b3*m.b20*m.b22*m.b39 + 64*
m.b3*m.b20*m.b23*m.b40 + 64*m.b3*m.b21*m.b22*m.b40 + 64*m.b4*m.b5*m.b6*m.b7 + 64*m.b4*m.b5*m.b7*
m.b8 + 64*m.b4*m.b5*m.b8*m.b9 + 64*m.b4*m.b5*m.b9*m.b10 + 64*m.b4*m.b5*m.b10*m.b11 + 64*m.b4*m.b5
*m.b11*m.b12 + 64*m.b4*m.b5*m.b12*m.b13 + 64*m.b4*m.b5*m.b13*m.b14 + 64*m.b4*m.b5*m.b14*m.b15 +
64*m.b4*m.b5*m.b15*m.b16 + 64*m.b4*m.b5*m.b16*m.b17 + 64*m.b4*m.b5*m.b17*m.b18 + 64*m.b4*m.b5*
m.b18*m.b19 + 256*m.b4*m.b5*m.b19*m.b20 + 256*m.b4*m.b5*m.b20*m.b21 + 256*m.b4*m.b5*m.b21*m.b22
+ 256*m.b4*m.b5*m.b22*m.b23 + 256*m.b4*m.b5*m.b23*m.b24 + 256*m.b4*m.b5*m.b24*m.b25 + 256*m.b4*
m.b5*m.b25*m.b26 + 256*m.b4*m.b5*m.b26*m.b27 + 256*m.b4*m.b5*m.b27*m.b28 + 256*m.b4*m.b5*m.b28*
m.b29 + 256*m.b4*m.b5*m.b29*m.b30 + 256*m.b4*m.b5*m.b30*m.b31 + 256*m.b4*m.b5*m.b31*m.b32 + 256*
m.b4*m.b5*m.b32*m.b33 + 256*m.b4*m.b5*m.b33*m.b34 + 256*m.b4*m.b5*m.b34*m.b35 + 256*m.b4*m.b5*
m.b35*m.b36 + 256*m.b4*m.b5*m.b36*m.b37 + 192*m.b4*m.b5*m.b37*m.b38 + 128*m.b4*m.b5*m.b38*m.b39
+ 64*m.b4*m.b5*m.b39*m.b40 + 64*m.b4*m.b6*m.b7*m.b9 + 64*m.b4*m.b6*m.b8*m.b10 + 64*m.b4*m.b6*
m.b9*m.b11 + 64*m.b4*m.b6*m.b10*m.b12 + 64*m.b4*m.b6*m.b11*m.b13 + 64*m.b4*m.b6*m.b12*m.b14 + 64*
m.b4*m.b6*m.b13*m.b15 + 64*m.b4*m.b6*m.b14*m.b16 + 64*m.b4*m.b6*m.b15*m.b17 + 64*m.b4*m.b6*m.b16*
m.b18 + 64*m.b4*m.b6*m.b17*m.b19 + 256*m.b4*m.b6*m.b18*m.b20 + 256*m.b4*m.b6*m.b19*m.b21 + 256*
m.b4*m.b6*m.b20*m.b22 + 256*m.b4*m.b6*m.b21*m.b23 + 256*m.b4*m.b6*m.b22*m.b24 + 256*m.b4*m.b6*
m.b23*m.b25 + 256*m.b4*m.b6*m.b24*m.b26 + 256*m.b4*m.b6*m.b25*m.b27 + 256*m.b4*m.b6*m.b26*m.b28
+ 256*m.b4*m.b6*m.b27*m.b29 + 256*m.b4*m.b6*m.b28*m.b30 + 256*m.b4*m.b6*m.b29*m.b31 + 256*m.b4*
m.b6*m.b30*m.b32 + 256*m.b4*m.b6*m.b31*m.b33 + 256*m.b4*m.b6*m.b32*m.b34 + 256*m.b4*m.b6*m.b33*
m.b35 + 256*m.b4*m.b6*m.b34*m.b36 + 256*m.b4*m.b6*m.b35*m.b37 + 192*m.b4*m.b6*m.b36*m.b38 + 128*
m.b4*m.b6*m.b37*m.b39 + 64*m.b4*m.b6*m.b38*m.b40 + 64*m.b4*m.b7*m.b8*m.b11 + 64*m.b4*m.b7*m.b9*
m.b12 + 64*m.b4*m.b7*m.b10*m.b13 + 64*m.b4*m.b7*m.b11*m.b14 + 64*m.b4*m.b7*m.b12*m.b15 + 64*m.b4*
m.b7*m.b13*m.b16 + 64*m.b4*m.b7*m.b14*m.b17 + 64*m.b4*m.b7*m.b15*m.b18 + 64*m.b4*m.b7*m.b16*m.b19
+ 256*m.b4*m.b7*m.b17*m.b20 + 256*m.b4*m.b7*m.b18*m.b21 + 256*m.b4*m.b7*m.b19*m.b22 + 256*m.b4*
m.b7*m.b20*m.b23 + 256*m.b4*m.b7*m.b21*m.b24 + 256*m.b4*m.b7*m.b22*m.b25 + 256*m.b4*m.b7*m.b23*
m.b26 + 256*m.b4*m.b7*m.b24*m.b27 + 256*m.b4*m.b7*m.b25*m.b28 + 256*m.b4*m.b7*m.b26*m.b29 + 256*
m.b4*m.b7*m.b27*m.b30 + 256*m.b4*m.b7*m.b28*m.b31 + 256*m.b4*m.b7*m.b29*m.b32 + 256*m.b4*m.b7*
m.b30*m.b33 + 256*m.b4*m.b7*m.b31*m.b34 + 256*m.b4*m.b7*m.b32*m.b35 + 256*m.b4*m.b7*m.b33*m.b36
+ 256*m.b4*m.b7*m.b34*m.b37 + 192*m.b4*m.b7*m.b35*m.b38 + 128*m.b4*m.b7*m.b36*m.b39 + 64*m.b4*
m.b7*m.b37*m.b40 + 64*m.b4*m.b8*m.b9*m.b13 + 64*m.b4*m.b8*m.b10*m.b14 + 64*m.b4*m.b8*m.b11*m.b15
+ 64*m.b4*m.b8*m.b12*m.b16 + 64*m.b4*m.b8*m.b13*m.b17 + 64*m.b4*m.b8*m.b14*m.b18 + 64*m.b4*m.b8*
m.b15*m.b19 + 256*m.b4*m.b8*m.b16*m.b20 + 256*m.b4*m.b8*m.b17*m.b21 + 256*m.b4*m.b8*m.b18*m.b22
+ 256*m.b4*m.b8*m.b19*m.b23 + 256*m.b4*m.b8*m.b20*m.b24 + 256*m.b4*m.b8*m.b21*m.b25 + 256*m.b4*
m.b8*m.b22*m.b26 + 256*m.b4*m.b8*m.b23*m.b27 + 256*m.b4*m.b8*m.b24*m.b28 + 256*m.b4*m.b8*m.b25*
m.b29 + 256*m.b4*m.b8*m.b26*m.b30 + 256*m.b4*m.b8*m.b27*m.b31 + 256*m.b4*m.b8*m.b28*m.b32 + 256*
m.b4*m.b8*m.b29*m.b33 + 256*m.b4*m.b8*m.b30*m.b34 + 256*m.b4*m.b8*m.b31*m.b35 + 256*m.b4*m.b8*
m.b32*m.b36 + 256*m.b4*m.b8*m.b33*m.b37 + 192*m.b4*m.b8*m.b34*m.b38 + 128*m.b4*m.b8*m.b35*m.b39
+ 64*m.b4*m.b8*m.b36*m.b40 + 64*m.b4*m.b9*m.b10*m.b15 + 64*m.b4*m.b9*m.b11*m.b16 + 64*m.b4*m.b9*
m.b12*m.b17 + 64*m.b4*m.b9*m.b13*m.b18 + 64*m.b4*m.b9*m.b14*m.b19 + 256*m.b4*m.b9*m.b15*m.b20 +
256*m.b4*m.b9*m.b16*m.b21 + 256*m.b4*m.b9*m.b17*m.b22 + 256*m.b4*m.b9*m.b18*m.b23 + 256*m.b4*m.b9
*m.b19*m.b24 + 256*m.b4*m.b9*m.b20*m.b25 + 256*m.b4*m.b9*m.b21*m.b26 + 256*m.b4*m.b9*m.b22*m.b27
+ 256*m.b4*m.b9*m.b23*m.b28 + 256*m.b4*m.b9*m.b24*m.b29 + 256*m.b4*m.b9*m.b25*m.b30 + 256*m.b4*
m.b9*m.b26*m.b31 + 256*m.b4*m.b9*m.b27*m.b32 + 256*m.b4*m.b9*m.b28*m.b33 + 256*m.b4*m.b9*m.b29*
m.b34 + 256*m.b4*m.b9*m.b30*m.b35 + 256*m.b4*m.b9*m.b31*m.b36 + 256*m.b4*m.b9*m.b32*m.b37 + 192*
m.b4*m.b9*m.b33*m.b38 + 128*m.b4*m.b9*m.b34*m.b39 + 64*m.b4*m.b9*m.b35*m.b40 + 64*m.b4*m.b10*
m.b11*m.b17 + 64*m.b4*m.b10*m.b12*m.b18 + 64*m.b4*m.b10*m.b13*m.b19 + 256*m.b4*m.b10*m.b14*m.b20
+ 256*m.b4*m.b10*m.b15*m.b21 + 256*m.b4*m.b10*m.b16*m.b22 + 256*m.b4*m.b10*m.b17*m.b23 + 256*
m.b4*m.b10*m.b18*m.b24 + 256*m.b4*m.b10*m.b19*m.b25 + 256*m.b4*m.b10*m.b20*m.b26 + 256*m.b4*m.b10
*m.b21*m.b27 + 256*m.b4*m.b10*m.b22*m.b28 + 256*m.b4*m.b10*m.b23*m.b29 + 256*m.b4*m.b10*m.b24*
m.b30 + 256*m.b4*m.b10*m.b25*m.b31 + 256*m.b4*m.b10*m.b26*m.b32 + 256*m.b4*m.b10*m.b27*m.b33 +
256*m.b4*m.b10*m.b28*m.b34 + 256*m.b4*m.b10*m.b29*m.b35 + 256*m.b4*m.b10*m.b30*m.b36 + 256*m.b4*
m.b10*m.b31*m.b37 + 192*m.b4*m.b10*m.b32*m.b38 + 128*m.b4*m.b10*m.b33*m.b39 + 64*m.b4*m.b10*m.b34
*m.b40 + 64*m.b4*m.b11*m.b12*m.b19 + 256*m.b4*m.b11*m.b13*m.b20 + 256*m.b4*m.b11*m.b14*m.b21 +
256*m.b4*m.b11*m.b15*m.b22 + 256*m.b4*m.b11*m.b16*m.b23 + 256*m.b4*m.b11*m.b17*m.b24 + 256*m.b4*
m.b11*m.b18*m.b25 + 256*m.b4*m.b11*m.b19*m.b26 + 256*m.b4*m.b11*m.b20*m.b27 + 256*m.b4*m.b11*
m.b21*m.b28 + 256*m.b4*m.b11*m.b22*m.b29 + 256*m.b4*m.b11*m.b23*m.b30 + 256*m.b4*m.b11*m.b24*
m.b31 + 256*m.b4*m.b11*m.b25*m.b32 + 256*m.b4*m.b11*m.b26*m.b33 + 256*m.b4*m.b11*m.b27*m.b34 +
256*m.b4*m.b11*m.b28*m.b35 + 256*m.b4*m.b11*m.b29*m.b36 + 256*m.b4*m.b11*m.b30*m.b37 + 192*m.b4*
m.b11*m.b31*m.b38 + 128*m.b4*m.b11*m.b32*m.b39 + 64*m.b4*m.b11*m.b33*m.b40 + 256*m.b4*m.b12*m.b13
*m.b21 + 256*m.b4*m.b12*m.b14*m.b22 + 256*m.b4*m.b12*m.b15*m.b23 + 256*m.b4*m.b12*m.b16*m.b24 +
256*m.b4*m.b12*m.b17*m.b25 + 256*m.b4*m.b12*m.b18*m.b26 + 256*m.b4*m.b12*m.b19*m.b27 + 256*m.b4*
m.b12*m.b20*m.b28 + 256*m.b4*m.b12*m.b21*m.b29 + 256*m.b4*m.b12*m.b22*m.b30 + 256*m.b4*m.b12*
m.b23*m.b31 + 256*m.b4*m.b12*m.b24*m.b32 + 256*m.b4*m.b12*m.b25*m.b33 + 256*m.b4*m.b12*m.b26*
m.b34 + 256*m.b4*m.b12*m.b27*m.b35 + 256*m.b4*m.b12*m.b28*m.b36 + 256*m.b4*m.b12*m.b29*m.b37 +
192*m.b4*m.b12*m.b30*m.b38 + 128*m.b4*m.b12*m.b31*m.b39 + 64*m.b4*m.b12*m.b32*m.b40 + 256*m.b4*
m.b13*m.b14*m.b23 + 256*m.b4*m.b13*m.b15*m.b24 + 256*m.b4*m.b13*m.b16*m.b25 + 256*m.b4*m.b13*
m.b17*m.b26 + 256*m.b4*m.b13*m.b18*m.b27 + 256*m.b4*m.b13*m.b19*m.b28 + 256*m.b4*m.b13*m.b20*
m.b29 + 256*m.b4*m.b13*m.b21*m.b30 + 256*m.b4*m.b13*m.b22*m.b31 + 256*m.b4*m.b13*m.b23*m.b32 +
256*m.b4*m.b13*m.b24*m.b33 + 256*m.b4*m.b13*m.b25*m.b34 + 256*m.b4*m.b13*m.b26*m.b35 + 256*m.b4*
m.b13*m.b27*m.b36 + 256*m.b4*m.b13*m.b28*m.b37 + 192*m.b4*m.b13*m.b29*m.b38 + 128*m.b4*m.b13*
m.b30*m.b39 + 64*m.b4*m.b13*m.b31*m.b40 + 256*m.b4*m.b14*m.b15*m.b25 + 256*m.b4*m.b14*m.b16*m.b26
+ 256*m.b4*m.b14*m.b17*m.b27 + 256*m.b4*m.b14*m.b18*m.b28 + 256*m.b4*m.b14*m.b19*m.b29 + 256*
m.b4*m.b14*m.b20*m.b30 + 256*m.b4*m.b14*m.b21*m.b31 + 256*m.b4*m.b14*m.b22*m.b32 + 256*m.b4*m.b14
*m.b23*m.b33 + 256*m.b4*m.b14*m.b24*m.b34 + 256*m.b4*m.b14*m.b25*m.b35 + 256*m.b4*m.b14*m.b26*
m.b36 + 256*m.b4*m.b14*m.b27*m.b37 + 192*m.b4*m.b14*m.b28*m.b38 + 128*m.b4*m.b14*m.b29*m.b39 + 64
*m.b4*m.b14*m.b30*m.b40 + 256*m.b4*m.b15*m.b16*m.b27 + 256*m.b4*m.b15*m.b17*m.b28 + 256*m.b4*
m.b15*m.b18*m.b29 + 256*m.b4*m.b15*m.b19*m.b30 + 256*m.b4*m.b15*m.b20*m.b31 + 256*m.b4*m.b15*
m.b21*m.b32 + 256*m.b4*m.b15*m.b22*m.b33 + 256*m.b4*m.b15*m.b23*m.b34 + 256*m.b4*m.b15*m.b24*
m.b35 + 256*m.b4*m.b15*m.b25*m.b36 + 256*m.b4*m.b15*m.b26*m.b37 + 192*m.b4*m.b15*m.b27*m.b38 +
128*m.b4*m.b15*m.b28*m.b39 + 64*m.b4*m.b15*m.b29*m.b40 + 256*m.b4*m.b16*m.b17*m.b29 + 256*m.b4*
m.b16*m.b18*m.b30 + 256*m.b4*m.b16*m.b19*m.b31 + 256*m.b4*m.b16*m.b20*m.b32 + 256*m.b4*m.b16*
m.b21*m.b33 + 256*m.b4*m.b16*m.b22*m.b34 + 256*m.b4*m.b16*m.b23*m.b35 + 256*m.b4*m.b16*m.b24*
m.b36 + 256*m.b4*m.b16*m.b25*m.b37 + 192*m.b4*m.b16*m.b26*m.b38 + 128*m.b4*m.b16*m.b27*m.b39 + 64
*m.b4*m.b16*m.b28*m.b40 + 256*m.b4*m.b17*m.b18*m.b31 + 256*m.b4*m.b17*m.b19*m.b32 + 256*m.b4*
m.b17*m.b20*m.b33 + 256*m.b4*m.b17*m.b21*m.b34 + 256*m.b4*m.b17*m.b22*m.b35 + 256*m.b4*m.b17*
m.b23*m.b36 + 256*m.b4*m.b17*m.b24*m.b37 + 192*m.b4*m.b17*m.b25*m.b38 + 128*m.b4*m.b17*m.b26*
m.b39 + 64*m.b4*m.b17*m.b27*m.b40 + 256*m.b4*m.b18*m.b19*m.b33 + 256*m.b4*m.b18*m.b20*m.b34 + 256
*m.b4*m.b18*m.b21*m.b35 + 256*m.b4*m.b18*m.b22*m.b36 + 256*m.b4*m.b18*m.b23*m.b37 + 192*m.b4*
m.b18*m.b24*m.b38 + 128*m.b4*m.b18*m.b25*m.b39 + 64*m.b4*m.b18*m.b26*m.b40 + 256*m.b4*m.b19*m.b20
*m.b35 + 256*m.b4*m.b19*m.b21*m.b36 + 256*m.b4*m.b19*m.b22*m.b37 + 192*m.b4*m.b19*m.b23*m.b38 +
128*m.b4*m.b19*m.b24*m.b39 + 64*m.b4*m.b19*m.b25*m.b40 + 256*m.b4*m.b20*m.b21*m.b37 + 192*m.b4*
m.b20*m.b22*m.b38 + 128*m.b4*m.b20*m.b23*m.b39 + 64*m.b4*m.b20*m.b24*m.b40 + 128*m.b4*m.b21*m.b22
*m.b39 + 64*m.b4*m.b21*m.b23*m.b40 + 64*m.b5*m.b6*m.b7*m.b8 + 64*m.b5*m.b6*m.b8*m.b9 + 64*m.b5*
m.b6*m.b9*m.b10 + 64*m.b5*m.b6*m.b10*m.b11 + 64*m.b5*m.b6*m.b11*m.b12 + 64*m.b5*m.b6*m.b12*m.b13
+ 64*m.b5*m.b6*m.b13*m.b14 + 64*m.b5*m.b6*m.b14*m.b15 + 64*m.b5*m.b6*m.b15*m.b16 + 64*m.b5*m.b6*
m.b16*m.b17 + 64*m.b5*m.b6*m.b17*m.b18 + 64*m.b5*m.b6*m.b18*m.b19 + 64*m.b5*m.b6*m.b19*m.b20 +
320*m.b5*m.b6*m.b20*m.b21 + 320*m.b5*m.b6*m.b21*m.b22 + 320*m.b5*m.b6*m.b22*m.b23 + 320*m.b5*m.b6
*m.b23*m.b24 + 320*m.b5*m.b6*m.b24*m.b25 + 320*m.b5*m.b6*m.b25*m.b26 + 320*m.b5*m.b6*m.b26*m.b27
+ 320*m.b5*m.b6*m.b27*m.b28 + 320*m.b5*m.b6*m.b28*m.b29 + 320*m.b5*m.b6*m.b29*m.b30 + 320*m.b5*
m.b6*m.b30*m.b31 + 320*m.b5*m.b6*m.b31*m.b32 + 320*m.b5*m.b6*m.b32*m.b33 + 320*m.b5*m.b6*m.b33*
m.b34 + 320*m.b5*m.b6*m.b34*m.b35 + 320*m.b5*m.b6*m.b35*m.b36 + 256*m.b5*m.b6*m.b36*m.b37 + 192*
m.b5*m.b6*m.b37*m.b38 + 128*m.b5*m.b6*m.b38*m.b39 + 64*m.b5*m.b6*m.b39*m.b40 + 64*m.b5*m.b7*m.b8*
m.b10 + 64*m.b5*m.b7*m.b9*m.b11 + 64*m.b5*m.b7*m.b10*m.b12 + 64*m.b5*m.b7*m.b11*m.b13 + 64*m.b5*
m.b7*m.b12*m.b14 + 64*m.b5*m.b7*m.b13*m.b15 + 64*m.b5*m.b7*m.b14*m.b16 + 64*m.b5*m.b7*m.b15*m.b17
+ 64*m.b5*m.b7*m.b16*m.b18 + 64*m.b5*m.b7*m.b17*m.b19 + 64*m.b5*m.b7*m.b18*m.b20 + 320*m.b5*m.b7
*m.b19*m.b21 + 320*m.b5*m.b7*m.b20*m.b22 + 320*m.b5*m.b7*m.b21*m.b23 + 320*m.b5*m.b7*m.b22*m.b24
+ 320*m.b5*m.b7*m.b23*m.b25 + 320*m.b5*m.b7*m.b24*m.b26 + 320*m.b5*m.b7*m.b25*m.b27 + 320*m.b5*
m.b7*m.b26*m.b28 + 320*m.b5*m.b7*m.b27*m.b29 + 320*m.b5*m.b7*m.b28*m.b30 + 320*m.b5*m.b7*m.b29*
m.b31 + 320*m.b5*m.b7*m.b30*m.b32 + 320*m.b5*m.b7*m.b31*m.b33 + 320*m.b5*m.b7*m.b32*m.b34 + 320*
m.b5*m.b7*m.b33*m.b35 + 320*m.b5*m.b7*m.b34*m.b36 + 256*m.b5*m.b7*m.b35*m.b37 + 192*m.b5*m.b7*
m.b36*m.b38 + 128*m.b5*m.b7*m.b37*m.b39 + 64*m.b5*m.b7*m.b38*m.b40 + 64*m.b5*m.b8*m.b9*m.b12 + 64
*m.b5*m.b8*m.b10*m.b13 + 64*m.b5*m.b8*m.b11*m.b14 + 64*m.b5*m.b8*m.b12*m.b15 + 64*m.b5*m.b8*m.b13
*m.b16 + 64*m.b5*m.b8*m.b14*m.b17 + 64*m.b5*m.b8*m.b15*m.b18 + 64*m.b5*m.b8*m.b16*m.b19 + 64*m.b5
*m.b8*m.b17*m.b20 + 320*m.b5*m.b8*m.b18*m.b21 + 320*m.b5*m.b8*m.b19*m.b22 + 320*m.b5*m.b8*m.b20*
m.b23 + 320*m.b5*m.b8*m.b21*m.b24 + 320*m.b5*m.b8*m.b22*m.b25 + 320*m.b5*m.b8*m.b23*m.b26 + 320*
m.b5*m.b8*m.b24*m.b27 + 320*m.b5*m.b8*m.b25*m.b28 + 320*m.b5*m.b8*m.b26*m.b29 + 320*m.b5*m.b8*
m.b27*m.b30 + 320*m.b5*m.b8*m.b28*m.b31 + 320*m.b5*m.b8*m.b29*m.b32 + 320*m.b5*m.b8*m.b30*m.b33
+ 320*m.b5*m.b8*m.b31*m.b34 + 320*m.b5*m.b8*m.b32*m.b35 + 320*m.b5*m.b8*m.b33*m.b36 + 256*m.b5*
m.b8*m.b34*m.b37 + 192*m.b5*m.b8*m.b35*m.b38 + 128*m.b5*m.b8*m.b36*m.b39 + 64*m.b5*m.b8*m.b37*
m.b40 + 64*m.b5*m.b9*m.b10*m.b14 + 64*m.b5*m.b9*m.b11*m.b15 + 64*m.b5*m.b9*m.b12*m.b16 + 64*m.b5*
m.b9*m.b13*m.b17 + 64*m.b5*m.b9*m.b14*m.b18 + 64*m.b5*m.b9*m.b15*m.b19 + 64*m.b5*m.b9*m.b16*m.b20
+ 320*m.b5*m.b9*m.b17*m.b21 + 320*m.b5*m.b9*m.b18*m.b22 + 320*m.b5*m.b9*m.b19*m.b23 + 320*m.b5*
m.b9*m.b20*m.b24 + 320*m.b5*m.b9*m.b21*m.b25 + 320*m.b5*m.b9*m.b22*m.b26 + 320*m.b5*m.b9*m.b23*
m.b27 + 320*m.b5*m.b9*m.b24*m.b28 + 320*m.b5*m.b9*m.b25*m.b29 + 320*m.b5*m.b9*m.b26*m.b30 + 320*
m.b5*m.b9*m.b27*m.b31 + 320*m.b5*m.b9*m.b28*m.b32 + 320*m.b5*m.b9*m.b29*m.b33 + 320*m.b5*m.b9*
m.b30*m.b34 + 320*m.b5*m.b9*m.b31*m.b35 + 320*m.b5*m.b9*m.b32*m.b36 + 256*m.b5*m.b9*m.b33*m.b37
+ 192*m.b5*m.b9*m.b34*m.b38 + 128*m.b5*m.b9*m.b35*m.b39 + 64*m.b5*m.b9*m.b36*m.b40 + 64*m.b5*
m.b10*m.b11*m.b16 + 64*m.b5*m.b10*m.b12*m.b17 + 64*m.b5*m.b10*m.b13*m.b18 + 64*m.b5*m.b10*m.b14*
m.b19 + 64*m.b5*m.b10*m.b15*m.b20 + 320*m.b5*m.b10*m.b16*m.b21 + 320*m.b5*m.b10*m.b17*m.b22 + 320
*m.b5*m.b10*m.b18*m.b23 + 320*m.b5*m.b10*m.b19*m.b24 + 320*m.b5*m.b10*m.b20*m.b25 + 320*m.b5*
m.b10*m.b21*m.b26 + 320*m.b5*m.b10*m.b22*m.b27 + 320*m.b5*m.b10*m.b23*m.b28 + 320*m.b5*m.b10*
m.b24*m.b29 + 320*m.b5*m.b10*m.b25*m.b30 + 320*m.b5*m.b10*m.b26*m.b31 + 320*m.b5*m.b10*m.b27*
m.b32 + 320*m.b5*m.b10*m.b28*m.b33 + 320*m.b5*m.b10*m.b29*m.b34 + 320*m.b5*m.b10*m.b30*m.b35 +
320*m.b5*m.b10*m.b31*m.b36 + 256*m.b5*m.b10*m.b32*m.b37 + 192*m.b5*m.b10*m.b33*m.b38 + 128*m.b5*
m.b10*m.b34*m.b39 + 64*m.b5*m.b10*m.b35*m.b40 + 64*m.b5*m.b11*m.b12*m.b18 + 64*m.b5*m.b11*m.b13*
m.b19 + 64*m.b5*m.b11*m.b14*m.b20 + 320*m.b5*m.b11*m.b15*m.b21 + 320*m.b5*m.b11*m.b16*m.b22 + 320
*m.b5*m.b11*m.b17*m.b23 + 320*m.b5*m.b11*m.b18*m.b24 + 320*m.b5*m.b11*m.b19*m.b25 + 320*m.b5*
m.b11*m.b20*m.b26 + 320*m.b5*m.b11*m.b21*m.b27 + 320*m.b5*m.b11*m.b22*m.b28 + 320*m.b5*m.b11*
m.b23*m.b29 + 320*m.b5*m.b11*m.b24*m.b30 + 320*m.b5*m.b11*m.b25*m.b31 + 320*m.b5*m.b11*m.b26*
m.b32 + 320*m.b5*m.b11*m.b27*m.b33 + 320*m.b5*m.b11*m.b28*m.b34 + 320*m.b5*m.b11*m.b29*m.b35 +
320*m.b5*m.b11*m.b30*m.b36 + 256*m.b5*m.b11*m.b31*m.b37 + 192*m.b5*m.b11*m.b32*m.b38 + 128*m.b5*
m.b11*m.b33*m.b39 + 64*m.b5*m.b11*m.b34*m.b40 + 64*m.b5*m.b12*m.b13*m.b20 + 320*m.b5*m.b12*m.b14*
m.b21 + 320*m.b5*m.b12*m.b15*m.b22 + 320*m.b5*m.b12*m.b16*m.b23 + 320*m.b5*m.b12*m.b17*m.b24 +
320*m.b5*m.b12*m.b18*m.b25 + 320*m.b5*m.b12*m.b19*m.b26 + 320*m.b5*m.b12*m.b20*m.b27 + 320*m.b5*
m.b12*m.b21*m.b28 + 320*m.b5*m.b12*m.b22*m.b29 + 320*m.b5*m.b12*m.b23*m.b30 + 320*m.b5*m.b12*
m.b24*m.b31 + 320*m.b5*m.b12*m.b25*m.b32 + 320*m.b5*m.b12*m.b26*m.b33 + 320*m.b5*m.b12*m.b27*
m.b34 + 320*m.b5*m.b12*m.b28*m.b35 + 320*m.b5*m.b12*m.b29*m.b36 + 256*m.b5*m.b12*m.b30*m.b37 +
192*m.b5*m.b12*m.b31*m.b38 + 128*m.b5*m.b12*m.b32*m.b39 + 64*m.b5*m.b12*m.b33*m.b40 + 320*m.b5*
m.b13*m.b14*m.b22 + 320*m.b5*m.b13*m.b15*m.b23 + 320*m.b5*m.b13*m.b16*m.b24 + 320*m.b5*m.b13*
m.b17*m.b25 + 320*m.b5*m.b13*m.b18*m.b26 + 320*m.b5*m.b13*m.b19*m.b27 + 320*m.b5*m.b13*m.b20*
m.b28 + 320*m.b5*m.b13*m.b21*m.b29 + 320*m.b5*m.b13*m.b22*m.b30 + 320*m.b5*m.b13*m.b23*m.b31 +
320*m.b5*m.b13*m.b24*m.b32 + 320*m.b5*m.b13*m.b25*m.b33 + 320*m.b5*m.b13*m.b26*m.b34 + 320*m.b5*
m.b13*m.b27*m.b35 + 320*m.b5*m.b13*m.b28*m.b36 + 256*m.b5*m.b13*m.b29*m.b37 + 192*m.b5*m.b13*
m.b30*m.b38 + 128*m.b5*m.b13*m.b31*m.b39 + 64*m.b5*m.b13*m.b32*m.b40 + 320*m.b5*m.b14*m.b15*m.b24
+ 320*m.b5*m.b14*m.b16*m.b25 + 320*m.b5*m.b14*m.b17*m.b26 + 320*m.b5*m.b14*m.b18*m.b27 + 320*
m.b5*m.b14*m.b19*m.b28 + 320*m.b5*m.b14*m.b20*m.b29 + 320*m.b5*m.b14*m.b21*m.b30 + 320*m.b5*m.b14
*m.b22*m.b31 + 320*m.b5*m.b14*m.b23*m.b32 + 320*m.b5*m.b14*m.b24*m.b33 + 320*m.b5*m.b14*m.b25*
m.b34 + 320*m.b5*m.b14*m.b26*m.b35 + 320*m.b5*m.b14*m.b27*m.b36 + 256*m.b5*m.b14*m.b28*m.b37 +
192*m.b5*m.b14*m.b29*m.b38 + 128*m.b5*m.b14*m.b30*m.b39 + 64*m.b5*m.b14*m.b31*m.b40 + 320*m.b5*
m.b15*m.b16*m.b26 + 320*m.b5*m.b15*m.b17*m.b27 + 320*m.b5*m.b15*m.b18*m.b28 + 320*m.b5*m.b15*
m.b19*m.b29 + 320*m.b5*m.b15*m.b20*m.b30 + 320*m.b5*m.b15*m.b21*m.b31 + 320*m.b5*m.b15*m.b22*
m.b32 + 320*m.b5*m.b15*m.b23*m.b33 + 320*m.b5*m.b15*m.b24*m.b34 + 320*m.b5*m.b15*m.b25*m.b35 +
320*m.b5*m.b15*m.b26*m.b36 + 256*m.b5*m.b15*m.b27*m.b37 + 192*m.b5*m.b15*m.b28*m.b38 + 128*m.b5*
m.b15*m.b29*m.b39 + 64*m.b5*m.b15*m.b30*m.b40 + 320*m.b5*m.b16*m.b17*m.b28 + 320*m.b5*m.b16*m.b18
*m.b29 + 320*m.b5*m.b16*m.b19*m.b30 + 320*m.b5*m.b16*m.b20*m.b31 + 320*m.b5*m.b16*m.b21*m.b32 +
320*m.b5*m.b16*m.b22*m.b33 + 320*m.b5*m.b16*m.b23*m.b34 + 320*m.b5*m.b16*m.b24*m.b35 + 320*m.b5*
m.b16*m.b25*m.b36 + 256*m.b5*m.b16*m.b26*m.b37 + 192*m.b5*m.b16*m.b27*m.b38 + 128*m.b5*m.b16*
m.b28*m.b39 + 64*m.b5*m.b16*m.b29*m.b40 + 320*m.b5*m.b17*m.b18*m.b30 + 320*m.b5*m.b17*m.b19*m.b31
+ 320*m.b5*m.b17*m.b20*m.b32 + 320*m.b5*m.b17*m.b21*m.b33 + 320*m.b5*m.b17*m.b22*m.b34 + 320*
m.b5*m.b17*m.b23*m.b35 + 320*m.b5*m.b17*m.b24*m.b36 + 256*m.b5*m.b17*m.b25*m.b37 + 192*m.b5*m.b17
*m.b26*m.b38 + 128*m.b5*m.b17*m.b27*m.b39 + 64*m.b5*m.b17*m.b28*m.b40 + 320*m.b5*m.b18*m.b19*
m.b32 + 320*m.b5*m.b18*m.b20*m.b33 + 320*m.b5*m.b18*m.b21*m.b34 + 320*m.b5*m.b18*m.b22*m.b35 +
320*m.b5*m.b18*m.b23*m.b36 + 256*m.b5*m.b18*m.b24*m.b37 + 192*m.b5*m.b18*m.b25*m.b38 + 128*m.b5*
m.b18*m.b26*m.b39 + 64*m.b5*m.b18*m.b27*m.b40 + 320*m.b5*m.b19*m.b20*m.b34 + 320*m.b5*m.b19*m.b21
*m.b35 + 320*m.b5*m.b19*m.b22*m.b36 + 256*m.b5*m.b19*m.b23*m.b37 + 192*m.b5*m.b19*m.b24*m.b38 +
128*m.b5*m.b19*m.b25*m.b39 + 64*m.b5*m.b19*m.b26*m.b40 + 320*m.b5*m.b20*m.b21*m.b36 + 256*m.b5*
m.b20*m.b22*m.b37 + 192*m.b5*m.b20*m.b23*m.b38 + 128*m.b5*m.b20*m.b24*m.b39 + 64*m.b5*m.b20*m.b25
*m.b40 + 192*m.b5*m.b21*m.b22*m.b38 + 128*m.b5*m.b21*m.b23*m.b39 + 64*m.b5*m.b21*m.b24*m.b40 + 64
*m.b5*m.b22*m.b23*m.b40 + 64*m.b6*m.b7*m.b8*m.b9 + 64*m.b6*m.b7*m.b9*m.b10 + 64*m.b6*m.b7*m.b10*
m.b11 + 64*m.b6*m.b7*m.b11*m.b12 + 64*m.b6*m.b7*m.b12*m.b13 + 64*m.b6*m.b7*m.b13*m.b14 + 64*m.b6*
m.b7*m.b14*m.b15 + 64*m.b6*m.b7*m.b15*m.b16 + 64*m.b6*m.b7*m.b16*m.b17 + 64*m.b6*m.b7*m.b17*m.b18
+ 64*m.b6*m.b7*m.b18*m.b19 + 64*m.b6*m.b7*m.b19*m.b20 + 64*m.b6*m.b7*m.b20*m.b21 + 384*m.b6*m.b7
*m.b21*m.b22 + 384*m.b6*m.b7*m.b22*m.b23 + 384*m.b6*m.b7*m.b23*m.b24 + 384*m.b6*m.b7*m.b24*m.b25
+ 384*m.b6*m.b7*m.b25*m.b26 + 384*m.b6*m.b7*m.b26*m.b27 + 384*m.b6*m.b7*m.b27*m.b28 + 384*m.b6*
m.b7*m.b28*m.b29 + 384*m.b6*m.b7*m.b29*m.b30 + 384*m.b6*m.b7*m.b30*m.b31 + 384*m.b6*m.b7*m.b31*
m.b32 + 384*m.b6*m.b7*m.b32*m.b33 + 384*m.b6*m.b7*m.b33*m.b34 + 384*m.b6*m.b7*m.b34*m.b35 + 320*
m.b6*m.b7*m.b35*m.b36 + 256*m.b6*m.b7*m.b36*m.b37 + 192*m.b6*m.b7*m.b37*m.b38 + 128*m.b6*m.b7*
m.b38*m.b39 + 64*m.b6*m.b7*m.b39*m.b40 + 64*m.b6*m.b8*m.b9*m.b11 + 64*m.b6*m.b8*m.b10*m.b12 + 64*
m.b6*m.b8*m.b11*m.b13 + 64*m.b6*m.b8*m.b12*m.b14 + 64*m.b6*m.b8*m.b13*m.b15 + 64*m.b6*m.b8*m.b14*
m.b16 + 64*m.b6*m.b8*m.b15*m.b17 + 64*m.b6*m.b8*m.b16*m.b18 + 64*m.b6*m.b8*m.b17*m.b19 + 64*m.b6*
m.b8*m.b18*m.b20 + 64*m.b6*m.b8*m.b19*m.b21 + 384*m.b6*m.b8*m.b20*m.b22 + 384*m.b6*m.b8*m.b21*
m.b23 + 384*m.b6*m.b8*m.b22*m.b24 + 384*m.b6*m.b8*m.b23*m.b25 + 384*m.b6*m.b8*m.b24*m.b26 + 384*
m.b6*m.b8*m.b25*m.b27 + 384*m.b6*m.b8*m.b26*m.b28 + 384*m.b6*m.b8*m.b27*m.b29 + 384*m.b6*m.b8*
m.b28*m.b30 + 384*m.b6*m.b8*m.b29*m.b31 + 384*m.b6*m.b8*m.b30*m.b32 + 384*m.b6*m.b8*m.b31*m.b33
+ 384*m.b6*m.b8*m.b32*m.b34 + 384*m.b6*m.b8*m.b33*m.b35 + 320*m.b6*m.b8*m.b34*m.b36 + 256*m.b6*
m.b8*m.b35*m.b37 + 192*m.b6*m.b8*m.b36*m.b38 + 128*m.b6*m.b8*m.b37*m.b39 + 64*m.b6*m.b8*m.b38*
m.b40 + 64*m.b6*m.b9*m.b10*m.b13 + 64*m.b6*m.b9*m.b11*m.b14 + 64*m.b6*m.b9*m.b12*m.b15 + 64*m.b6*
m.b9*m.b13*m.b16 + 64*m.b6*m.b9*m.b14*m.b17 + 64*m.b6*m.b9*m.b15*m.b18 + 64*m.b6*m.b9*m.b16*m.b19
+ 64*m.b6*m.b9*m.b17*m.b20 + 64*m.b6*m.b9*m.b18*m.b21 + 384*m.b6*m.b9*m.b19*m.b22 + 384*m.b6*
m.b9*m.b20*m.b23 + 384*m.b6*m.b9*m.b21*m.b24 + 384*m.b6*m.b9*m.b22*m.b25 + 384*m.b6*m.b9*m.b23*
m.b26 + 384*m.b6*m.b9*m.b24*m.b27 + 384*m.b6*m.b9*m.b25*m.b28 + 384*m.b6*m.b9*m.b26*m.b29 + 384*
m.b6*m.b9*m.b27*m.b30 + 384*m.b6*m.b9*m.b28*m.b31 + 384*m.b6*m.b9*m.b29*m.b32 + 384*m.b6*m.b9*
m.b30*m.b33 + 384*m.b6*m.b9*m.b31*m.b34 + 384*m.b6*m.b9*m.b32*m.b35 + 320*m.b6*m.b9*m.b33*m.b36
+ 256*m.b6*m.b9*m.b34*m.b37 + 192*m.b6*m.b9*m.b35*m.b38 + 128*m.b6*m.b9*m.b36*m.b39 + 64*m.b6*
m.b9*m.b37*m.b40 + 64*m.b6*m.b10*m.b11*m.b15 + 64*m.b6*m.b10*m.b12*m.b16 + 64*m.b6*m.b10*m.b13*
m.b17 + 64*m.b6*m.b10*m.b14*m.b18 + 64*m.b6*m.b10*m.b15*m.b19 + 64*m.b6*m.b10*m.b16*m.b20 + 64*
m.b6*m.b10*m.b17*m.b21 + 384*m.b6*m.b10*m.b18*m.b22 + 384*m.b6*m.b10*m.b19*m.b23 + 384*m.b6*m.b10
*m.b20*m.b24 + 384*m.b6*m.b10*m.b21*m.b25 + 384*m.b6*m.b10*m.b22*m.b26 + 384*m.b6*m.b10*m.b23*
m.b27 + 384*m.b6*m.b10*m.b24*m.b28 + 384*m.b6*m.b10*m.b25*m.b29 + 384*m.b6*m.b10*m.b26*m.b30 +
384*m.b6*m.b10*m.b27*m.b31 + 384*m.b6*m.b10*m.b28*m.b32 + 384*m.b6*m.b10*m.b29*m.b33 + 384*m.b6*
m.b10*m.b30*m.b34 + 384*m.b6*m.b10*m.b31*m.b35 + 320*m.b6*m.b10*m.b32*m.b36 + 256*m.b6*m.b10*
m.b33*m.b37 + 192*m.b6*m.b10*m.b34*m.b38 + 128*m.b6*m.b10*m.b35*m.b39 + 64*m.b6*m.b10*m.b36*m.b40
+ 64*m.b6*m.b11*m.b12*m.b17 + 64*m.b6*m.b11*m.b13*m.b18 + 64*m.b6*m.b11*m.b14*m.b19 + 64*m.b6*
m.b11*m.b15*m.b20 + 64*m.b6*m.b11*m.b16*m.b21 + 384*m.b6*m.b11*m.b17*m.b22 + 384*m.b6*m.b11*m.b18
*m.b23 + 384*m.b6*m.b11*m.b19*m.b24 + 384*m.b6*m.b11*m.b20*m.b25 + 384*m.b6*m.b11*m.b21*m.b26 +
384*m.b6*m.b11*m.b22*m.b27 + 384*m.b6*m.b11*m.b23*m.b28 + 384*m.b6*m.b11*m.b24*m.b29 + 384*m.b6*
m.b11*m.b25*m.b30 + 384*m.b6*m.b11*m.b26*m.b31 + 384*m.b6*m.b11*m.b27*m.b32 + 384*m.b6*m.b11*
m.b28*m.b33 + 384*m.b6*m.b11*m.b29*m.b34 + 384*m.b6*m.b11*m.b30*m.b35 + 320*m.b6*m.b11*m.b31*
m.b36 + 256*m.b6*m.b11*m.b32*m.b37 + 192*m.b6*m.b11*m.b33*m.b38 + 128*m.b6*m.b11*m.b34*m.b39 + 64
*m.b6*m.b11*m.b35*m.b40 + 64*m.b6*m.b12*m.b13*m.b19 + 64*m.b6*m.b12*m.b14*m.b20 + 64*m.b6*m.b12*
m.b15*m.b21 + 384*m.b6*m.b12*m.b16*m.b22 + 384*m.b6*m.b12*m.b17*m.b23 + 384*m.b6*m.b12*m.b18*
m.b24 + 384*m.b6*m.b12*m.b19*m.b25 + 384*m.b6*m.b12*m.b20*m.b26 + 384*m.b6*m.b12*m.b21*m.b27 +
384*m.b6*m.b12*m.b22*m.b28 + 384*m.b6*m.b12*m.b23*m.b29 + 384*m.b6*m.b12*m.b24*m.b30 + 384*m.b6*
m.b12*m.b25*m.b31 + 384*m.b6*m.b12*m.b26*m.b32 + 384*m.b6*m.b12*m.b27*m.b33 + 384*m.b6*m.b12*
m.b28*m.b34 + 384*m.b6*m.b12*m.b29*m.b35 + 320*m.b6*m.b12*m.b30*m.b36 + 256*m.b6*m.b12*m.b31*
m.b37 + 192*m.b6*m.b12*m.b32*m.b38 + 128*m.b6*m.b12*m.b33*m.b39 + 64*m.b6*m.b12*m.b34*m.b40 + 64*
m.b6*m.b13*m.b14*m.b21 + 384*m.b6*m.b13*m.b15*m.b22 + 384*m.b6*m.b13*m.b16*m.b23 + 384*m.b6*m.b13
*m.b17*m.b24 + 384*m.b6*m.b13*m.b18*m.b25 + 384*m.b6*m.b13*m.b19*m.b26 + 384*m.b6*m.b13*m.b20*
m.b27 + 384*m.b6*m.b13*m.b21*m.b28 + 384*m.b6*m.b13*m.b22*m.b29 + 384*m.b6*m.b13*m.b23*m.b30 +
384*m.b6*m.b13*m.b24*m.b31 + 384*m.b6*m.b13*m.b25*m.b32 + 384*m.b6*m.b13*m.b26*m.b33 + 384*m.b6*
m.b13*m.b27*m.b34 + 384*m.b6*m.b13*m.b28*m.b35 + 320*m.b6*m.b13*m.b29*m.b36 + 256*m.b6*m.b13*
m.b30*m.b37 + 192*m.b6*m.b13*m.b31*m.b38 + 128*m.b6*m.b13*m.b32*m.b39 + 64*m.b6*m.b13*m.b33*m.b40
+ 384*m.b6*m.b14*m.b15*m.b23 + 384*m.b6*m.b14*m.b16*m.b24 + 384*m.b6*m.b14*m.b17*m.b25 + 384*
m.b6*m.b14*m.b18*m.b26 + 384*m.b6*m.b14*m.b19*m.b27 + 384*m.b6*m.b14*m.b20*m.b28 + 384*m.b6*m.b14
*m.b21*m.b29 + 384*m.b6*m.b14*m.b22*m.b30 + 384*m.b6*m.b14*m.b23*m.b31 + 384*m.b6*m.b14*m.b24*
m.b32 + 384*m.b6*m.b14*m.b25*m.b33 + 384*m.b6*m.b14*m.b26*m.b34 + 384*m.b6*m.b14*m.b27*m.b35 +
320*m.b6*m.b14*m.b28*m.b36 + 256*m.b6*m.b14*m.b29*m.b37 + 192*m.b6*m.b14*m.b30*m.b38 + 128*m.b6*
m.b14*m.b31*m.b39 + 64*m.b6*m.b14*m.b32*m.b40 + 384*m.b6*m.b15*m.b16*m.b25 + 384*m.b6*m.b15*m.b17
*m.b26 + 384*m.b6*m.b15*m.b18*m.b27 + 384*m.b6*m.b15*m.b19*m.b28 + 384*m.b6*m.b15*m.b20*m.b29 +
384*m.b6*m.b15*m.b21*m.b30 + 384*m.b6*m.b15*m.b22*m.b31 + 384*m.b6*m.b15*m.b23*m.b32 + 384*m.b6*
m.b15*m.b24*m.b33 + 384*m.b6*m.b15*m.b25*m.b34 + 384*m.b6*m.b15*m.b26*m.b35 + 320*m.b6*m.b15*
m.b27*m.b36 + 256*m.b6*m.b15*m.b28*m.b37 + 192*m.b6*m.b15*m.b29*m.b38 + 128*m.b6*m.b15*m.b30*
m.b39 + 64*m.b6*m.b15*m.b31*m.b40 + 384*m.b6*m.b16*m.b17*m.b27 + 384*m.b6*m.b16*m.b18*m.b28 + 384
*m.b6*m.b16*m.b19*m.b29 + 384*m.b6*m.b16*m.b20*m.b30 + 384*m.b6*m.b16*m.b21*m.b31 + 384*m.b6*
m.b16*m.b22*m.b32 + 384*m.b6*m.b16*m.b23*m.b33 + 384*m.b6*m.b16*m.b24*m.b34 + 384*m.b6*m.b16*
m.b25*m.b35 + 320*m.b6*m.b16*m.b26*m.b36 + 256*m.b6*m.b16*m.b27*m.b37 + 192*m.b6*m.b16*m.b28*
m.b38 + 128*m.b6*m.b16*m.b29*m.b39 + 64*m.b6*m.b16*m.b30*m.b40 + 384*m.b6*m.b17*m.b18*m.b29 + 384
*m.b6*m.b17*m.b19*m.b30 + 384*m.b6*m.b17*m.b20*m.b31 + 384*m.b6*m.b17*m.b21*m.b32 + 384*m.b6*
m.b17*m.b22*m.b33 + 384*m.b6*m.b17*m.b23*m.b34 + 384*m.b6*m.b17*m.b24*m.b35 + 320*m.b6*m.b17*
m.b25*m.b36 + 256*m.b6*m.b17*m.b26*m.b37 + 192*m.b6*m.b17*m.b27*m.b38 + 128*m.b6*m.b17*m.b28*
m.b39 + 64*m.b6*m.b17*m.b29*m.b40 + 384*m.b6*m.b18*m.b19*m.b31 + 384*m.b6*m.b18*m.b20*m.b32 + 384
*m.b6*m.b18*m.b21*m.b33 + 384*m.b6*m.b18*m.b22*m.b34 + 384*m.b6*m.b18*m.b23*m.b35 + 320*m.b6*
m.b18*m.b24*m.b36 + 256*m.b6*m.b18*m.b25*m.b37 + 192*m.b6*m.b18*m.b26*m.b38 + 128*m.b6*m.b18*
m.b27*m.b39 + 64*m.b6*m.b18*m.b28*m.b40 + 384*m.b6*m.b19*m.b20*m.b33 + 384*m.b6*m.b19*m.b21*m.b34
+ 384*m.b6*m.b19*m.b22*m.b35 + 320*m.b6*m.b19*m.b23*m.b36 + 256*m.b6*m.b19*m.b24*m.b37 + 192*
m.b6*m.b19*m.b25*m.b38 + 128*m.b6*m.b19*m.b26*m.b39 + 64*m.b6*m.b19*m.b27*m.b40 + 384*m.b6*m.b20*
m.b21*m.b35 + 320*m.b6*m.b20*m.b22*m.b36 + 256*m.b6*m.b20*m.b23*m.b37 + 192*m.b6*m.b20*m.b24*
m.b38 + 128*m.b6*m.b20*m.b25*m.b39 + 64*m.b6*m.b20*m.b26*m.b40 + 256*m.b6*m.b21*m.b22*m.b37 + 192
*m.b6*m.b21*m.b23*m.b38 + 128*m.b6*m.b21*m.b24*m.b39 + 64*m.b6*m.b21*m.b25*m.b40 + 128*m.b6*m.b22
*m.b23*m.b39 + 64*m.b6*m.b22*m.b24*m.b40 + 64*m.b7*m.b8*m.b9*m.b10 + 64*m.b7*m.b8*m.b10*m.b11 +
64*m.b7*m.b8*m.b11*m.b12 + 64*m.b7*m.b8*m.b12*m.b13 + 64*m.b7*m.b8*m.b13*m.b14 + 64*m.b7*m.b8*
m.b14*m.b15 + 64*m.b7*m.b8*m.b15*m.b16 + 64*m.b7*m.b8*m.b16*m.b17 + 64*m.b7*m.b8*m.b17*m.b18 + 64
*m.b7*m.b8*m.b18*m.b19 + 64*m.b7*m.b8*m.b19*m.b20 + 64*m.b7*m.b8*m.b20*m.b21 + 64*m.b7*m.b8*m.b21
*m.b22 + 448*m.b7*m.b8*m.b22*m.b23 + 448*m.b7*m.b8*m.b23*m.b24 + 448*m.b7*m.b8*m.b24*m.b25 + 448*
m.b7*m.b8*m.b25*m.b26 + 448*m.b7*m.b8*m.b26*m.b27 + 448*m.b7*m.b8*m.b27*m.b28 + 448*m.b7*m.b8*
m.b28*m.b29 + 448*m.b7*m.b8*m.b29*m.b30 + 448*m.b7*m.b8*m.b30*m.b31 + 448*m.b7*m.b8*m.b31*m.b32
+ 448*m.b7*m.b8*m.b32*m.b33 + 448*m.b7*m.b8*m.b33*m.b34 + 384*m.b7*m.b8*m.b34*m.b35 + 320*m.b7*
m.b8*m.b35*m.b36 + 256*m.b7*m.b8*m.b36*m.b37 + 192*m.b7*m.b8*m.b37*m.b38 + 128*m.b7*m.b8*m.b38*
m.b39 + 64*m.b7*m.b8*m.b39*m.b40 + 64*m.b7*m.b9*m.b10*m.b12 + 64*m.b7*m.b9*m.b11*m.b13 + 64*m.b7*
m.b9*m.b12*m.b14 + 64*m.b7*m.b9*m.b13*m.b15 + 64*m.b7*m.b9*m.b14*m.b16 + 64*m.b7*m.b9*m.b15*m.b17
+ 64*m.b7*m.b9*m.b16*m.b18 + 64*m.b7*m.b9*m.b17*m.b19 + 64*m.b7*m.b9*m.b18*m.b20 + 64*m.b7*m.b9*
m.b19*m.b21 + 64*m.b7*m.b9*m.b20*m.b22 + 448*m.b7*m.b9*m.b21*m.b23 + 448*m.b7*m.b9*m.b22*m.b24 +
448*m.b7*m.b9*m.b23*m.b25 + 448*m.b7*m.b9*m.b24*m.b26 + 448*m.b7*m.b9*m.b25*m.b27 + 448*m.b7*m.b9
*m.b26*m.b28 + 448*m.b7*m.b9*m.b27*m.b29 + 448*m.b7*m.b9*m.b28*m.b30 + 448*m.b7*m.b9*m.b29*m.b31
+ 448*m.b7*m.b9*m.b30*m.b32 + 448*m.b7*m.b9*m.b31*m.b33 + 448*m.b7*m.b9*m.b32*m.b34 + 384*m.b7*
m.b9*m.b33*m.b35 + 320*m.b7*m.b9*m.b34*m.b36 + 256*m.b7*m.b9*m.b35*m.b37 + 192*m.b7*m.b9*m.b36*
m.b38 + 128*m.b7*m.b9*m.b37*m.b39 + 64*m.b7*m.b9*m.b38*m.b40 + 64*m.b7*m.b10*m.b11*m.b14 + 64*
m.b7*m.b10*m.b12*m.b15 + 64*m.b7*m.b10*m.b13*m.b16 + 64*m.b7*m.b10*m.b14*m.b17 + 64*m.b7*m.b10*
m.b15*m.b18 + 64*m.b7*m.b10*m.b16*m.b19 + 64*m.b7*m.b10*m.b17*m.b20 + 64*m.b7*m.b10*m.b18*m.b21
+ 64*m.b7*m.b10*m.b19*m.b22 + 448*m.b7*m.b10*m.b20*m.b23 + 448*m.b7*m.b10*m.b21*m.b24 + 448*m.b7
*m.b10*m.b22*m.b25 + 448*m.b7*m.b10*m.b23*m.b26 + 448*m.b7*m.b10*m.b24*m.b27 + 448*m.b7*m.b10*
m.b25*m.b28 + 448*m.b7*m.b10*m.b26*m.b29 + 448*m.b7*m.b10*m.b27*m.b30 + 448*m.b7*m.b10*m.b28*
m.b31 + 448*m.b7*m.b10*m.b29*m.b32 + 448*m.b7*m.b10*m.b30*m.b33 + 448*m.b7*m.b10*m.b31*m.b34 +
384*m.b7*m.b10*m.b32*m.b35 + 320*m.b7*m.b10*m.b33*m.b36 + 256*m.b7*m.b10*m.b34*m.b37 + 192*m.b7*
m.b10*m.b35*m.b38 + 128*m.b7*m.b10*m.b36*m.b39 + 64*m.b7*m.b10*m.b37*m.b40 + 64*m.b7*m.b11*m.b12*
m.b16 + 64*m.b7*m.b11*m.b13*m.b17 + 64*m.b7*m.b11*m.b14*m.b18 + 64*m.b7*m.b11*m.b15*m.b19 + 64*
m.b7*m.b11*m.b16*m.b20 + 64*m.b7*m.b11*m.b17*m.b21 + 64*m.b7*m.b11*m.b18*m.b22 + 448*m.b7*m.b11*
m.b19*m.b23 + 448*m.b7*m.b11*m.b20*m.b24 + 448*m.b7*m.b11*m.b21*m.b25 + 448*m.b7*m.b11*m.b22*
m.b26 + 448*m.b7*m.b11*m.b23*m.b27 + 448*m.b7*m.b11*m.b24*m.b28 + 448*m.b7*m.b11*m.b25*m.b29 +
448*m.b7*m.b11*m.b26*m.b30 + 448*m.b7*m.b11*m.b27*m.b31 + 448*m.b7*m.b11*m.b28*m.b32 + 448*m.b7*
m.b11*m.b29*m.b33 + 448*m.b7*m.b11*m.b30*m.b34 + 384*m.b7*m.b11*m.b31*m.b35 + 320*m.b7*m.b11*
m.b32*m.b36 + 256*m.b7*m.b11*m.b33*m.b37 + 192*m.b7*m.b11*m.b34*m.b38 + 128*m.b7*m.b11*m.b35*
m.b39 + 64*m.b7*m.b11*m.b36*m.b40 + 64*m.b7*m.b12*m.b13*m.b18 + 64*m.b7*m.b12*m.b14*m.b19 + 64*
m.b7*m.b12*m.b15*m.b20 + 64*m.b7*m.b12*m.b16*m.b21 + 64*m.b7*m.b12*m.b17*m.b22 + 448*m.b7*m.b12*
m.b18*m.b23 + 448*m.b7*m.b12*m.b19*m.b24 + 448*m.b7*m.b12*m.b20*m.b25 + 448*m.b7*m.b12*m.b21*
m.b26 + 448*m.b7*m.b12*m.b22*m.b27 + 448*m.b7*m.b12*m.b23*m.b28 + 448*m.b7*m.b12*m.b24*m.b29 +
448*m.b7*m.b12*m.b25*m.b30 + 448*m.b7*m.b12*m.b26*m.b31 + 448*m.b7*m.b12*m.b27*m.b32 + 448*m.b7*
m.b12*m.b28*m.b33 + 448*m.b7*m.b12*m.b29*m.b34 + 384*m.b7*m.b12*m.b30*m.b35 + 320*m.b7*m.b12*
m.b31*m.b36 + 256*m.b7*m.b12*m.b32*m.b37 + 192*m.b7*m.b12*m.b33*m.b38 + 128*m.b7*m.b12*m.b34*
m.b39 + 64*m.b7*m.b12*m.b35*m.b40 + 64*m.b7*m.b13*m.b14*m.b20 + 64*m.b7*m.b13*m.b15*m.b21 + 64*
m.b7*m.b13*m.b16*m.b22 + 448*m.b7*m.b13*m.b17*m.b23 + 448*m.b7*m.b13*m.b18*m.b24 + 448*m.b7*m.b13
*m.b19*m.b25 + 448*m.b7*m.b13*m.b20*m.b26 + 448*m.b7*m.b13*m.b21*m.b27 + 448*m.b7*m.b13*m.b22*
m.b28 + 448*m.b7*m.b13*m.b23*m.b29 + 448*m.b7*m.b13*m.b24*m.b30 + 448*m.b7*m.b13*m.b25*m.b31 +
448*m.b7*m.b13*m.b26*m.b32 + 448*m.b7*m.b13*m.b27*m.b33 + 448*m.b7*m.b13*m.b28*m.b34 + 384*m.b7*
m.b13*m.b29*m.b35 + 320*m.b7*m.b13*m.b30*m.b36 + 256*m.b7*m.b13*m.b31*m.b37 + 192*m.b7*m.b13*
m.b32*m.b38 + 128*m.b7*m.b13*m.b33*m.b39 + 64*m.b7*m.b13*m.b34*m.b40 + 64*m.b7*m.b14*m.b15*m.b22
+ 448*m.b7*m.b14*m.b16*m.b23 + 448*m.b7*m.b14*m.b17*m.b24 + 448*m.b7*m.b14*m.b18*m.b25 + 448*
m.b7*m.b14*m.b19*m.b26 + 448*m.b7*m.b14*m.b20*m.b27 + 448*m.b7*m.b14*m.b21*m.b28 + 448*m.b7*m.b14
*m.b22*m.b29 + 448*m.b7*m.b14*m.b23*m.b30 + 448*m.b7*m.b14*m.b24*m.b31 + 448*m.b7*m.b14*m.b25*
m.b32 + 448*m.b7*m.b14*m.b26*m.b33 + 448*m.b7*m.b14*m.b27*m.b34 + 384*m.b7*m.b14*m.b28*m.b35 +
320*m.b7*m.b14*m.b29*m.b36 + 256*m.b7*m.b14*m.b30*m.b37 + 192*m.b7*m.b14*m.b31*m.b38 + 128*m.b7*
m.b14*m.b32*m.b39 + 64*m.b7*m.b14*m.b33*m.b40 + 448*m.b7*m.b15*m.b16*m.b24 + 448*m.b7*m.b15*m.b17
*m.b25 + 448*m.b7*m.b15*m.b18*m.b26 + 448*m.b7*m.b15*m.b19*m.b27 + 448*m.b7*m.b15*m.b20*m.b28 +
448*m.b7*m.b15*m.b21*m.b29 + 448*m.b7*m.b15*m.b22*m.b30 + 448*m.b7*m.b15*m.b23*m.b31 + 448*m.b7*
m.b15*m.b24*m.b32 + 448*m.b7*m.b15*m.b25*m.b33 + 448*m.b7*m.b15*m.b26*m.b34 + 384*m.b7*m.b15*
m.b27*m.b35 + 320*m.b7*m.b15*m.b28*m.b36 + 256*m.b7*m.b15*m.b29*m.b37 + 192*m.b7*m.b15*m.b30*
m.b38 + 128*m.b7*m.b15*m.b31*m.b39 + 64*m.b7*m.b15*m.b32*m.b40 + 448*m.b7*m.b16*m.b17*m.b26 + 448
*m.b7*m.b16*m.b18*m.b27 + 448*m.b7*m.b16*m.b19*m.b28 + 448*m.b7*m.b16*m.b20*m.b29 + 448*m.b7*
m.b16*m.b21*m.b30 + 448*m.b7*m.b16*m.b22*m.b31 + 448*m.b7*m.b16*m.b23*m.b32 + 448*m.b7*m.b16*
m.b24*m.b33 + 448*m.b7*m.b16*m.b25*m.b34 + 384*m.b7*m.b16*m.b26*m.b35 + 320*m.b7*m.b16*m.b27*
m.b36 + 256*m.b7*m.b16*m.b28*m.b37 + 192*m.b7*m.b16*m.b29*m.b38 + 128*m.b7*m.b16*m.b30*m.b39 + 64
*m.b7*m.b16*m.b31*m.b40 + 448*m.b7*m.b17*m.b18*m.b28 + 448*m.b7*m.b17*m.b19*m.b29 + 448*m.b7*
m.b17*m.b20*m.b30 + 448*m.b7*m.b17*m.b21*m.b31 + 448*m.b7*m.b17*m.b22*m.b32 + 448*m.b7*m.b17*
m.b23*m.b33 + 448*m.b7*m.b17*m.b24*m.b34 + 384*m.b7*m.b17*m.b25*m.b35 + 320*m.b7*m.b17*m.b26*
m.b36 + 256*m.b7*m.b17*m.b27*m.b37 + 192*m.b7*m.b17*m.b28*m.b38 + 128*m.b7*m.b17*m.b29*m.b39 + 64
*m.b7*m.b17*m.b30*m.b40 + 448*m.b7*m.b18*m.b19*m.b30 + 448*m.b7*m.b18*m.b20*m.b31 + 448*m.b7*
m.b18*m.b21*m.b32 + 448*m.b7*m.b18*m.b22*m.b33 + 448*m.b7*m.b18*m.b23*m.b34 + 384*m.b7*m.b18*
m.b24*m.b35 + 320*m.b7*m.b18*m.b25*m.b36 + 256*m.b7*m.b18*m.b26*m.b37 + 192*m.b7*m.b18*m.b27*
m.b38 + 128*m.b7*m.b18*m.b28*m.b39 + 64*m.b7*m.b18*m.b29*m.b40 + 448*m.b7*m.b19*m.b20*m.b32 + 448
*m.b7*m.b19*m.b21*m.b33 + 448*m.b7*m.b19*m.b22*m.b34 + 384*m.b7*m.b19*m.b23*m.b35 + 320*m.b7*
m.b19*m.b24*m.b36 + 256*m.b7*m.b19*m.b25*m.b37 + 192*m.b7*m.b19*m.b26*m.b38 + 128*m.b7*m.b19*
m.b27*m.b39 + 64*m.b7*m.b19*m.b28*m.b40 + 448*m.b7*m.b20*m.b21*m.b34 + 384*m.b7*m.b20*m.b22*m.b35
+ 320*m.b7*m.b20*m.b23*m.b36 + 256*m.b7*m.b20*m.b24*m.b37 + 192*m.b7*m.b20*m.b25*m.b38 + 128*
m.b7*m.b20*m.b26*m.b39 + 64*m.b7*m.b20*m.b27*m.b40 + 320*m.b7*m.b21*m.b22*m.b36 + 256*m.b7*m.b21*
m.b23*m.b37 + 192*m.b7*m.b21*m.b24*m.b38 + 128*m.b7*m.b21*m.b25*m.b39 + 64*m.b7*m.b21*m.b26*m.b40
+ 192*m.b7*m.b22*m.b23*m.b38 + 128*m.b7*m.b22*m.b24*m.b39 + 64*m.b7*m.b22*m.b25*m.b40 + 64*m.b7*
m.b23*m.b24*m.b40 + 64*m.b8*m.b9*m.b10*m.b11 + 64*m.b8*m.b9*m.b11*m.b12 + 64*m.b8*m.b9*m.b12*
m.b13 + 64*m.b8*m.b9*m.b13*m.b14 + 64*m.b8*m.b9*m.b14*m.b15 + 64*m.b8*m.b9*m.b15*m.b16 + 64*m.b8*
m.b9*m.b16*m.b17 + 64*m.b8*m.b9*m.b17*m.b18 + 64*m.b8*m.b9*m.b18*m.b19 + 64*m.b8*m.b9*m.b19*m.b20
+ 64*m.b8*m.b9*m.b20*m.b21 + 64*m.b8*m.b9*m.b21*m.b22 + 64*m.b8*m.b9*m.b22*m.b23 + 512*m.b8*m.b9
*m.b23*m.b24 + 512*m.b8*m.b9*m.b24*m.b25 + 512*m.b8*m.b9*m.b25*m.b26 + 512*m.b8*m.b9*m.b26*m.b27
+ 512*m.b8*m.b9*m.b27*m.b28 + 512*m.b8*m.b9*m.b28*m.b29 + 512*m.b8*m.b9*m.b29*m.b30 + 512*m.b8*
m.b9*m.b30*m.b31 + 512*m.b8*m.b9*m.b31*m.b32 + 512*m.b8*m.b9*m.b32*m.b33 + 448*m.b8*m.b9*m.b33*
m.b34 + 384*m.b8*m.b9*m.b34*m.b35 + 320*m.b8*m.b9*m.b35*m.b36 + 256*m.b8*m.b9*m.b36*m.b37 + 192*
m.b8*m.b9*m.b37*m.b38 + 128*m.b8*m.b9*m.b38*m.b39 + 64*m.b8*m.b9*m.b39*m.b40 + 64*m.b8*m.b10*
m.b11*m.b13 + 64*m.b8*m.b10*m.b12*m.b14 + 64*m.b8*m.b10*m.b13*m.b15 + 64*m.b8*m.b10*m.b14*m.b16
+ 64*m.b8*m.b10*m.b15*m.b17 + 64*m.b8*m.b10*m.b16*m.b18 + 64*m.b8*m.b10*m.b17*m.b19 + 64*m.b8*
m.b10*m.b18*m.b20 + 64*m.b8*m.b10*m.b19*m.b21 + 64*m.b8*m.b10*m.b20*m.b22 + 64*m.b8*m.b10*m.b21*
m.b23 + 512*m.b8*m.b10*m.b22*m.b24 + 512*m.b8*m.b10*m.b23*m.b25 + 512*m.b8*m.b10*m.b24*m.b26 +
512*m.b8*m.b10*m.b25*m.b27 + 512*m.b8*m.b10*m.b26*m.b28 + 512*m.b8*m.b10*m.b27*m.b29 + 512*m.b8*
m.b10*m.b28*m.b30 + 512*m.b8*m.b10*m.b29*m.b31 + 512*m.b8*m.b10*m.b30*m.b32 + 512*m.b8*m.b10*
m.b31*m.b33 + 448*m.b8*m.b10*m.b32*m.b34 + 384*m.b8*m.b10*m.b33*m.b35 + 320*m.b8*m.b10*m.b34*
m.b36 + 256*m.b8*m.b10*m.b35*m.b37 + 192*m.b8*m.b10*m.b36*m.b38 + 128*m.b8*m.b10*m.b37*m.b39 + 64
*m.b8*m.b10*m.b38*m.b40 + 64*m.b8*m.b11*m.b12*m.b15 + 64*m.b8*m.b11*m.b13*m.b16 + 64*m.b8*m.b11*
m.b14*m.b17 + 64*m.b8*m.b11*m.b15*m.b18 + 64*m.b8*m.b11*m.b16*m.b19 + 64*m.b8*m.b11*m.b17*m.b20
+ 64*m.b8*m.b11*m.b18*m.b21 + 64*m.b8*m.b11*m.b19*m.b22 + 64*m.b8*m.b11*m.b20*m.b23 + 512*m.b8*
m.b11*m.b21*m.b24 + 512*m.b8*m.b11*m.b22*m.b25 + 512*m.b8*m.b11*m.b23*m.b26 + 512*m.b8*m.b11*
m.b24*m.b27 + 512*m.b8*m.b11*m.b25*m.b28 + 512*m.b8*m.b11*m.b26*m.b29 + 512*m.b8*m.b11*m.b27*
m.b30 + 512*m.b8*m.b11*m.b28*m.b31 + 512*m.b8*m.b11*m.b29*m.b32 + 512*m.b8*m.b11*m.b30*m.b33 +
448*m.b8*m.b11*m.b31*m.b34 + 384*m.b8*m.b11*m.b32*m.b35 + 320*m.b8*m.b11*m.b33*m.b36 + 256*m.b8*
m.b11*m.b34*m.b37 + 192*m.b8*m.b11*m.b35*m.b38 + 128*m.b8*m.b11*m.b36*m.b39 + 64*m.b8*m.b11*m.b37
*m.b40 + 64*m.b8*m.b12*m.b13*m.b17 + 64*m.b8*m.b12*m.b14*m.b18 + 64*m.b8*m.b12*m.b15*m.b19 + 64*
m.b8*m.b12*m.b16*m.b20 + 64*m.b8*m.b12*m.b17*m.b21 + 64*m.b8*m.b12*m.b18*m.b22 + 64*m.b8*m.b12*
m.b19*m.b23 + 512*m.b8*m.b12*m.b20*m.b24 + 512*m.b8*m.b12*m.b21*m.b25 + 512*m.b8*m.b12*m.b22*
m.b26 + 512*m.b8*m.b12*m.b23*m.b27 + 512*m.b8*m.b12*m.b24*m.b28 + 512*m.b8*m.b12*m.b25*m.b29 +
512*m.b8*m.b12*m.b26*m.b30 + 512*m.b8*m.b12*m.b27*m.b31 + 512*m.b8*m.b12*m.b28*m.b32 + 512*m.b8*
m.b12*m.b29*m.b33 + 448*m.b8*m.b12*m.b30*m.b34 + 384*m.b8*m.b12*m.b31*m.b35 + 320*m.b8*m.b12*
m.b32*m.b36 + 256*m.b8*m.b12*m.b33*m.b37 + 192*m.b8*m.b12*m.b34*m.b38 + 128*m.b8*m.b12*m.b35*
m.b39 + 64*m.b8*m.b12*m.b36*m.b40 + 64*m.b8*m.b13*m.b14*m.b19 + 64*m.b8*m.b13*m.b15*m.b20 + 64*
m.b8*m.b13*m.b16*m.b21 + 64*m.b8*m.b13*m.b17*m.b22 + 64*m.b8*m.b13*m.b18*m.b23 + 512*m.b8*m.b13*
m.b19*m.b24 + 512*m.b8*m.b13*m.b20*m.b25 + 512*m.b8*m.b13*m.b21*m.b26 + 512*m.b8*m.b13*m.b22*
m.b27 + 512*m.b8*m.b13*m.b23*m.b28 + 512*m.b8*m.b13*m.b24*m.b29 + 512*m.b8*m.b13*m.b25*m.b30 +
512*m.b8*m.b13*m.b26*m.b31 + 512*m.b8*m.b13*m.b27*m.b32 + 512*m.b8*m.b13*m.b28*m.b33 + 448*m.b8*
m.b13*m.b29*m.b34 + 384*m.b8*m.b13*m.b30*m.b35 + 320*m.b8*m.b13*m.b31*m.b36 + 256*m.b8*m.b13*
m.b32*m.b37 + 192*m.b8*m.b13*m.b33*m.b38 + 128*m.b8*m.b13*m.b34*m.b39 + 64*m.b8*m.b13*m.b35*m.b40
+ 64*m.b8*m.b14*m.b15*m.b21 + 64*m.b8*m.b14*m.b16*m.b22 + 64*m.b8*m.b14*m.b17*m.b23 + 512*m.b8*
m.b14*m.b18*m.b24 + 512*m.b8*m.b14*m.b19*m.b25 + 512*m.b8*m.b14*m.b20*m.b26 + 512*m.b8*m.b14*
m.b21*m.b27 + 512*m.b8*m.b14*m.b22*m.b28 + 512*m.b8*m.b14*m.b23*m.b29 + 512*m.b8*m.b14*m.b24*
m.b30 + 512*m.b8*m.b14*m.b25*m.b31 + 512*m.b8*m.b14*m.b26*m.b32 + 512*m.b8*m.b14*m.b27*m.b33 +
448*m.b8*m.b14*m.b28*m.b34 + 384*m.b8*m.b14*m.b29*m.b35 + 320*m.b8*m.b14*m.b30*m.b36 + 256*m.b8*
m.b14*m.b31*m.b37 + 192*m.b8*m.b14*m.b32*m.b38 + 128*m.b8*m.b14*m.b33*m.b39 + 64*m.b8*m.b14*m.b34
*m.b40 + 64*m.b8*m.b15*m.b16*m.b23 + 512*m.b8*m.b15*m.b17*m.b24 + 512*m.b8*m.b15*m.b18*m.b25 +
512*m.b8*m.b15*m.b19*m.b26 + 512*m.b8*m.b15*m.b20*m.b27 + 512*m.b8*m.b15*m.b21*m.b28 + 512*m.b8*
m.b15*m.b22*m.b29 + 512*m.b8*m.b15*m.b23*m.b30 + 512*m.b8*m.b15*m.b24*m.b31 + 512*m.b8*m.b15*
m.b25*m.b32 + 512*m.b8*m.b15*m.b26*m.b33 + 448*m.b8*m.b15*m.b27*m.b34 + 384*m.b8*m.b15*m.b28*
m.b35 + 320*m.b8*m.b15*m.b29*m.b36 + 256*m.b8*m.b15*m.b30*m.b37 + 192*m.b8*m.b15*m.b31*m.b38 +
128*m.b8*m.b15*m.b32*m.b39 + 64*m.b8*m.b15*m.b33*m.b40 + 512*m.b8*m.b16*m.b17*m.b25 + 512*m.b8*
m.b16*m.b18*m.b26 + 512*m.b8*m.b16*m.b19*m.b27 + 512*m.b8*m.b16*m.b20*m.b28 + 512*m.b8*m.b16*
m.b21*m.b29 + 512*m.b8*m.b16*m.b22*m.b30 + 512*m.b8*m.b16*m.b23*m.b31 + 512*m.b8*m.b16*m.b24*
m.b32 + 512*m.b8*m.b16*m.b25*m.b33 + 448*m.b8*m.b16*m.b26*m.b34 + 384*m.b8*m.b16*m.b27*m.b35 +
320*m.b8*m.b16*m.b28*m.b36 + 256*m.b8*m.b16*m.b29*m.b37 + 192*m.b8*m.b16*m.b30*m.b38 + 128*m.b8*
m.b16*m.b31*m.b39 + 64*m.b8*m.b16*m.b32*m.b40 + 512*m.b8*m.b17*m.b18*m.b27 + 512*m.b8*m.b17*m.b19
*m.b28 + 512*m.b8*m.b17*m.b20*m.b29 + 512*m.b8*m.b17*m.b21*m.b30 + 512*m.b8*m.b17*m.b22*m.b31 +
512*m.b8*m.b17*m.b23*m.b32 + 512*m.b8*m.b17*m.b24*m.b33 + 448*m.b8*m.b17*m.b25*m.b34 + 384*m.b8*
m.b17*m.b26*m.b35 + 320*m.b8*m.b17*m.b27*m.b36 + 256*m.b8*m.b17*m.b28*m.b37 + 192*m.b8*m.b17*
m.b29*m.b38 + 128*m.b8*m.b17*m.b30*m.b39 + 64*m.b8*m.b17*m.b31*m.b40 + 512*m.b8*m.b18*m.b19*m.b29
+ 512*m.b8*m.b18*m.b20*m.b30 + 512*m.b8*m.b18*m.b21*m.b31 + 512*m.b8*m.b18*m.b22*m.b32 + 512*
m.b8*m.b18*m.b23*m.b33 + 448*m.b8*m.b18*m.b24*m.b34 + 384*m.b8*m.b18*m.b25*m.b35 + 320*m.b8*m.b18
*m.b26*m.b36 + 256*m.b8*m.b18*m.b27*m.b37 + 192*m.b8*m.b18*m.b28*m.b38 + 128*m.b8*m.b18*m.b29*
m.b39 + 64*m.b8*m.b18*m.b30*m.b40 + 512*m.b8*m.b19*m.b20*m.b31 + 512*m.b8*m.b19*m.b21*m.b32 + 512
*m.b8*m.b19*m.b22*m.b33 + 448*m.b8*m.b19*m.b23*m.b34 + 384*m.b8*m.b19*m.b24*m.b35 + 320*m.b8*
m.b19*m.b25*m.b36 + 256*m.b8*m.b19*m.b26*m.b37 + 192*m.b8*m.b19*m.b27*m.b38 + 128*m.b8*m.b19*
m.b28*m.b39 + 64*m.b8*m.b19*m.b29*m.b40 + 512*m.b8*m.b20*m.b21*m.b33 + 448*m.b8*m.b20*m.b22*m.b34
+ 384*m.b8*m.b20*m.b23*m.b35 + 320*m.b8*m.b20*m.b24*m.b36 + 256*m.b8*m.b20*m.b25*m.b37 + 192*
m.b8*m.b20*m.b26*m.b38 + 128*m.b8*m.b20*m.b27*m.b39 + 64*m.b8*m.b20*m.b28*m.b40 + 384*m.b8*m.b21*
m.b22*m.b35 + 320*m.b8*m.b21*m.b23*m.b36 + 256*m.b8*m.b21*m.b24*m.b37 + 192*m.b8*m.b21*m.b25*
m.b38 + 128*m.b8*m.b21*m.b26*m.b39 + 64*m.b8*m.b21*m.b27*m.b40 + 256*m.b8*m.b22*m.b23*m.b37 + 192
*m.b8*m.b22*m.b24*m.b38 + 128*m.b8*m.b22*m.b25*m.b39 + 64*m.b8*m.b22*m.b26*m.b40 + 128*m.b8*m.b23
*m.b24*m.b39 + 64*m.b8*m.b23*m.b25*m.b40 + 64*m.b9*m.b10*m.b11*m.b12 + 64*m.b9*m.b10*m.b12*m.b13
+ 64*m.b9*m.b10*m.b13*m.b14 + 64*m.b9*m.b10*m.b14*m.b15 + 64*m.b9*m.b10*m.b15*m.b16 + 64*m.b9*
m.b10*m.b16*m.b17 + 64*m.b9*m.b10*m.b17*m.b18 + 64*m.b9*m.b10*m.b18*m.b19 + 64*m.b9*m.b10*m.b19*
m.b20 + 64*m.b9*m.b10*m.b20*m.b21 + 64*m.b9*m.b10*m.b21*m.b22 + 64*m.b9*m.b10*m.b22*m.b23 + 64*
m.b9*m.b10*m.b23*m.b24 + 576*m.b9*m.b10*m.b24*m.b25 + 576*m.b9*m.b10*m.b25*m.b26 + 576*m.b9*m.b10
*m.b26*m.b27 + 576*m.b9*m.b10*m.b27*m.b28 + 576*m.b9*m.b10*m.b28*m.b29 + 576*m.b9*m.b10*m.b29*
m.b30 + 576*m.b9*m.b10*m.b30*m.b31 + 576*m.b9*m.b10*m.b31*m.b32 + 512*m.b9*m.b10*m.b32*m.b33 +
448*m.b9*m.b10*m.b33*m.b34 + 384*m.b9*m.b10*m.b34*m.b35 + 320*m.b9*m.b10*m.b35*m.b36 + 256*m.b9*
m.b10*m.b36*m.b37 + 192*m.b9*m.b10*m.b37*m.b38 + 128*m.b9*m.b10*m.b38*m.b39 + 64*m.b9*m.b10*m.b39
*m.b40 + 64*m.b9*m.b11*m.b12*m.b14 + 64*m.b9*m.b11*m.b13*m.b15 + 64*m.b9*m.b11*m.b14*m.b16 + 64*
m.b9*m.b11*m.b15*m.b17 + 64*m.b9*m.b11*m.b16*m.b18 + 64*m.b9*m.b11*m.b17*m.b19 + 64*m.b9*m.b11*
m.b18*m.b20 + 64*m.b9*m.b11*m.b19*m.b21 + 64*m.b9*m.b11*m.b20*m.b22 + 64*m.b9*m.b11*m.b21*m.b23
+ 64*m.b9*m.b11*m.b22*m.b24 + 576*m.b9*m.b11*m.b23*m.b25 + 576*m.b9*m.b11*m.b24*m.b26 + 576*m.b9
*m.b11*m.b25*m.b27 + 576*m.b9*m.b11*m.b26*m.b28 + 576*m.b9*m.b11*m.b27*m.b29 + 576*m.b9*m.b11*
m.b28*m.b30 + 576*m.b9*m.b11*m.b29*m.b31 + 576*m.b9*m.b11*m.b30*m.b32 + 512*m.b9*m.b11*m.b31*
m.b33 + 448*m.b9*m.b11*m.b32*m.b34 + 384*m.b9*m.b11*m.b33*m.b35 + 320*m.b9*m.b11*m.b34*m.b36 +
256*m.b9*m.b11*m.b35*m.b37 + 192*m.b9*m.b11*m.b36*m.b38 + 128*m.b9*m.b11*m.b37*m.b39 + 64*m.b9*
m.b11*m.b38*m.b40 + 64*m.b9*m.b12*m.b13*m.b16 + 64*m.b9*m.b12*m.b14*m.b17 + 64*m.b9*m.b12*m.b15*
m.b18 + 64*m.b9*m.b12*m.b16*m.b19 + 64*m.b9*m.b12*m.b17*m.b20 + 64*m.b9*m.b12*m.b18*m.b21 + 64*
m.b9*m.b12*m.b19*m.b22 + 64*m.b9*m.b12*m.b20*m.b23 + 64*m.b9*m.b12*m.b21*m.b24 + 576*m.b9*m.b12*
m.b22*m.b25 + 576*m.b9*m.b12*m.b23*m.b26 + 576*m.b9*m.b12*m.b24*m.b27 + 576*m.b9*m.b12*m.b25*
m.b28 + 576*m.b9*m.b12*m.b26*m.b29 + 576*m.b9*m.b12*m.b27*m.b30 + 576*m.b9*m.b12*m.b28*m.b31 +
576*m.b9*m.b12*m.b29*m.b32 + 512*m.b9*m.b12*m.b30*m.b33 + 448*m.b9*m.b12*m.b31*m.b34 + 384*m.b9*
m.b12*m.b32*m.b35 + 320*m.b9*m.b12*m.b33*m.b36 + 256*m.b9*m.b12*m.b34*m.b37 + 192*m.b9*m.b12*
m.b35*m.b38 + 128*m.b9*m.b12*m.b36*m.b39 + 64*m.b9*m.b12*m.b37*m.b40 + 64*m.b9*m.b13*m.b14*m.b18
+ 64*m.b9*m.b13*m.b15*m.b19 + 64*m.b9*m.b13*m.b16*m.b20 + 64*m.b9*m.b13*m.b17*m.b21 + 64*m.b9*
m.b13*m.b18*m.b22 + 64*m.b9*m.b13*m.b19*m.b23 + 64*m.b9*m.b13*m.b20*m.b24 + 576*m.b9*m.b13*m.b21*
m.b25 + 576*m.b9*m.b13*m.b22*m.b26 + 576*m.b9*m.b13*m.b23*m.b27 + 576*m.b9*m.b13*m.b24*m.b28 +
576*m.b9*m.b13*m.b25*m.b29 + 576*m.b9*m.b13*m.b26*m.b30 + 576*m.b9*m.b13*m.b27*m.b31 + 576*m.b9*
m.b13*m.b28*m.b32 + 512*m.b9*m.b13*m.b29*m.b33 + 448*m.b9*m.b13*m.b30*m.b34 + 384*m.b9*m.b13*
m.b31*m.b35 + 320*m.b9*m.b13*m.b32*m.b36 + 256*m.b9*m.b13*m.b33*m.b37 + 192*m.b9*m.b13*m.b34*
m.b38 + 128*m.b9*m.b13*m.b35*m.b39 + 64*m.b9*m.b13*m.b36*m.b40 + 64*m.b9*m.b14*m.b15*m.b20 + 64*
m.b9*m.b14*m.b16*m.b21 + 64*m.b9*m.b14*m.b17*m.b22 + 64*m.b9*m.b14*m.b18*m.b23 + 64*m.b9*m.b14*
m.b19*m.b24 + 576*m.b9*m.b14*m.b20*m.b25 + 576*m.b9*m.b14*m.b21*m.b26 + 576*m.b9*m.b14*m.b22*
m.b27 + 576*m.b9*m.b14*m.b23*m.b28 + 576*m.b9*m.b14*m.b24*m.b29 + 576*m.b9*m.b14*m.b25*m.b30 +
576*m.b9*m.b14*m.b26*m.b31 + 576*m.b9*m.b14*m.b27*m.b32 + 512*m.b9*m.b14*m.b28*m.b33 + 448*m.b9*
m.b14*m.b29*m.b34 + 384*m.b9*m.b14*m.b30*m.b35 + 320*m.b9*m.b14*m.b31*m.b36 + 256*m.b9*m.b14*
m.b32*m.b37 + 192*m.b9*m.b14*m.b33*m.b38 + 128*m.b9*m.b14*m.b34*m.b39 + 64*m.b9*m.b14*m.b35*m.b40
+ 64*m.b9*m.b15*m.b16*m.b22 + 64*m.b9*m.b15*m.b17*m.b23 + 64*m.b9*m.b15*m.b18*m.b24 + 576*m.b9*
m.b15*m.b19*m.b25 + 576*m.b9*m.b15*m.b20*m.b26 + 576*m.b9*m.b15*m.b21*m.b27 + 576*m.b9*m.b15*
m.b22*m.b28 + 576*m.b9*m.b15*m.b23*m.b29 + 576*m.b9*m.b15*m.b24*m.b30 + 576*m.b9*m.b15*m.b25*
m.b31 + 576*m.b9*m.b15*m.b26*m.b32 + 512*m.b9*m.b15*m.b27*m.b33 + 448*m.b9*m.b15*m.b28*m.b34 +
384*m.b9*m.b15*m.b29*m.b35 + 320*m.b9*m.b15*m.b30*m.b36 + 256*m.b9*m.b15*m.b31*m.b37 + 192*m.b9*
m.b15*m.b32*m.b38 + 128*m.b9*m.b15*m.b33*m.b39 + 64*m.b9*m.b15*m.b34*m.b40 + 64*m.b9*m.b16*m.b17*
m.b24 + 576*m.b9*m.b16*m.b18*m.b25 + 576*m.b9*m.b16*m.b19*m.b26 + 576*m.b9*m.b16*m.b20*m.b27 +
576*m.b9*m.b16*m.b21*m.b28 + 576*m.b9*m.b16*m.b22*m.b29 + 576*m.b9*m.b16*m.b23*m.b30 + 576*m.b9*
m.b16*m.b24*m.b31 + 576*m.b9*m.b16*m.b25*m.b32 + 512*m.b9*m.b16*m.b26*m.b33 + 448*m.b9*m.b16*
m.b27*m.b34 + 384*m.b9*m.b16*m.b28*m.b35 + 320*m.b9*m.b16*m.b29*m.b36 + 256*m.b9*m.b16*m.b30*
m.b37 + 192*m.b9*m.b16*m.b31*m.b38 + 128*m.b9*m.b16*m.b32*m.b39 + 64*m.b9*m.b16*m.b33*m.b40 + 576
*m.b9*m.b17*m.b18*m.b26 + 576*m.b9*m.b17*m.b19*m.b27 + 576*m.b9*m.b17*m.b20*m.b28 + 576*m.b9*
m.b17*m.b21*m.b29 + 576*m.b9*m.b17*m.b22*m.b30 + 576*m.b9*m.b17*m.b23*m.b31 + 576*m.b9*m.b17*
m.b24*m.b32 + 512*m.b9*m.b17*m.b25*m.b33 + 448*m.b9*m.b17*m.b26*m.b34 + 384*m.b9*m.b17*m.b27*
m.b35 + 320*m.b9*m.b17*m.b28*m.b36 + 256*m.b9*m.b17*m.b29*m.b37 + 192*m.b9*m.b17*m.b30*m.b38 +
128*m.b9*m.b17*m.b31*m.b39 + 64*m.b9*m.b17*m.b32*m.b40 + 576*m.b9*m.b18*m.b19*m.b28 + 576*m.b9*
m.b18*m.b20*m.b29 + 576*m.b9*m.b18*m.b21*m.b30 + 576*m.b9*m.b18*m.b22*m.b31 + 576*m.b9*m.b18*
m.b23*m.b32 + 512*m.b9*m.b18*m.b24*m.b33 + 448*m.b9*m.b18*m.b25*m.b34 + 384*m.b9*m.b18*m.b26*
m.b35 + 320*m.b9*m.b18*m.b27*m.b36 + 256*m.b9*m.b18*m.b28*m.b37 + 192*m.b9*m.b18*m.b29*m.b38 +
128*m.b9*m.b18*m.b30*m.b39 + 64*m.b9*m.b18*m.b31*m.b40 + 576*m.b9*m.b19*m.b20*m.b30 + 576*m.b9*
m.b19*m.b21*m.b31 + 576*m.b9*m.b19*m.b22*m.b32 + 512*m.b9*m.b19*m.b23*m.b33 + 448*m.b9*m.b19*
m.b24*m.b34 + 384*m.b9*m.b19*m.b25*m.b35 + 320*m.b9*m.b19*m.b26*m.b36 + 256*m.b9*m.b19*m.b27*
m.b37 + 192*m.b9*m.b19*m.b28*m.b38 + 128*m.b9*m.b19*m.b29*m.b39 + 64*m.b9*m.b19*m.b30*m.b40 + 576
*m.b9*m.b20*m.b21*m.b32 + 512*m.b9*m.b20*m.b22*m.b33 + 448*m.b9*m.b20*m.b23*m.b34 + 384*m.b9*
m.b20*m.b24*m.b35 + 320*m.b9*m.b20*m.b25*m.b36 + 256*m.b9*m.b20*m.b26*m.b37 + 192*m.b9*m.b20*
m.b27*m.b38 + 128*m.b9*m.b20*m.b28*m.b39 + 64*m.b9*m.b20*m.b29*m.b40 + 448*m.b9*m.b21*m.b22*m.b34
+ 384*m.b9*m.b21*m.b23*m.b35 + 320*m.b9*m.b21*m.b24*m.b36 + 256*m.b9*m.b21*m.b25*m.b37 + 192*
m.b9*m.b21*m.b26*m.b38 + 128*m.b9*m.b21*m.b27*m.b39 + 64*m.b9*m.b21*m.b28*m.b40 + 320*m.b9*m.b22*
m.b23*m.b36 + 256*m.b9*m.b22*m.b24*m.b37 + 192*m.b9*m.b22*m.b25*m.b38 + 128*m.b9*m.b22*m.b26*
m.b39 + 64*m.b9*m.b22*m.b27*m.b40 + 192*m.b9*m.b23*m.b24*m.b38 + 128*m.b9*m.b23*m.b25*m.b39 + 64*
m.b9*m.b23*m.b26*m.b40 + 64*m.b9*m.b24*m.b25*m.b40 + 64*m.b10*m.b11*m.b12*m.b13 + 64*m.b10*m.b11*
m.b13*m.b14 + 64*m.b10*m.b11*m.b14*m.b15 + 64*m.b10*m.b11*m.b15*m.b16 + 64*m.b10*m.b11*m.b16*
m.b17 + 64*m.b10*m.b11*m.b17*m.b18 + 64*m.b10*m.b11*m.b18*m.b19 + 64*m.b10*m.b11*m.b19*m.b20 + 64
*m.b10*m.b11*m.b20*m.b21 + 64*m.b10*m.b11*m.b21*m.b22 + 64*m.b10*m.b11*m.b22*m.b23 + 64*m.b10*
m.b11*m.b23*m.b24 + 64*m.b10*m.b11*m.b24*m.b25 + 640*m.b10*m.b11*m.b25*m.b26 + 640*m.b10*m.b11*
m.b26*m.b27 + 640*m.b10*m.b11*m.b27*m.b28 + 640*m.b10*m.b11*m.b28*m.b29 + 640*m.b10*m.b11*m.b29*
m.b30 + 640*m.b10*m.b11*m.b30*m.b31 + 576*m.b10*m.b11*m.b31*m.b32 + 512*m.b10*m.b11*m.b32*m.b33
+ 448*m.b10*m.b11*m.b33*m.b34 + 384*m.b10*m.b11*m.b34*m.b35 + 320*m.b10*m.b11*m.b35*m.b36 + 256*
m.b10*m.b11*m.b36*m.b37 + 192*m.b10*m.b11*m.b37*m.b38 + 128*m.b10*m.b11*m.b38*m.b39 + 64*m.b10*
m.b11*m.b39*m.b40 + 64*m.b10*m.b12*m.b13*m.b15 + 64*m.b10*m.b12*m.b14*m.b16 + 64*m.b10*m.b12*
m.b15*m.b17 + 64*m.b10*m.b12*m.b16*m.b18 + 64*m.b10*m.b12*m.b17*m.b19 + 64*m.b10*m.b12*m.b18*
m.b20 + 64*m.b10*m.b12*m.b19*m.b21 + 64*m.b10*m.b12*m.b20*m.b22 + 64*m.b10*m.b12*m.b21*m.b23 + 64
*m.b10*m.b12*m.b22*m.b24 + 64*m.b10*m.b12*m.b23*m.b25 + 640*m.b10*m.b12*m.b24*m.b26 + 640*m.b10*
m.b12*m.b25*m.b27 + 640*m.b10*m.b12*m.b26*m.b28 + 640*m.b10*m.b12*m.b27*m.b29 + 640*m.b10*m.b12*
m.b28*m.b30 + 640*m.b10*m.b12*m.b29*m.b31 + 576*m.b10*m.b12*m.b30*m.b32 + 512*m.b10*m.b12*m.b31*
m.b33 + 448*m.b10*m.b12*m.b32*m.b34 + 384*m.b10*m.b12*m.b33*m.b35 + 320*m.b10*m.b12*m.b34*m.b36
+ 256*m.b10*m.b12*m.b35*m.b37 + 192*m.b10*m.b12*m.b36*m.b38 + 128*m.b10*m.b12*m.b37*m.b39 + 64*
m.b10*m.b12*m.b38*m.b40 + 64*m.b10*m.b13*m.b14*m.b17 + 64*m.b10*m.b13*m.b15*m.b18 + 64*m.b10*
m.b13*m.b16*m.b19 + 64*m.b10*m.b13*m.b17*m.b20 + 64*m.b10*m.b13*m.b18*m.b21 + 64*m.b10*m.b13*
m.b19*m.b22 + 64*m.b10*m.b13*m.b20*m.b23 + 64*m.b10*m.b13*m.b21*m.b24 + 64*m.b10*m.b13*m.b22*
m.b25 + 640*m.b10*m.b13*m.b23*m.b26 + 640*m.b10*m.b13*m.b24*m.b27 + 640*m.b10*m.b13*m.b25*m.b28
+ 640*m.b10*m.b13*m.b26*m.b29 + 640*m.b10*m.b13*m.b27*m.b30 + 640*m.b10*m.b13*m.b28*m.b31 + 576*
m.b10*m.b13*m.b29*m.b32 + 512*m.b10*m.b13*m.b30*m.b33 + 448*m.b10*m.b13*m.b31*m.b34 + 384*m.b10*
m.b13*m.b32*m.b35 + 320*m.b10*m.b13*m.b33*m.b36 + 256*m.b10*m.b13*m.b34*m.b37 + 192*m.b10*m.b13*
m.b35*m.b38 + 128*m.b10*m.b13*m.b36*m.b39 + 64*m.b10*m.b13*m.b37*m.b40 + 64*m.b10*m.b14*m.b15*
m.b19 + 64*m.b10*m.b14*m.b16*m.b20 + 64*m.b10*m.b14*m.b17*m.b21 + 64*m.b10*m.b14*m.b18*m.b22 + 64
*m.b10*m.b14*m.b19*m.b23 + 64*m.b10*m.b14*m.b20*m.b24 + 64*m.b10*m.b14*m.b21*m.b25 + 640*m.b10*
m.b14*m.b22*m.b26 + 640*m.b10*m.b14*m.b23*m.b27 + 640*m.b10*m.b14*m.b24*m.b28 + 640*m.b10*m.b14*
m.b25*m.b29 + 640*m.b10*m.b14*m.b26*m.b30 + 640*m.b10*m.b14*m.b27*m.b31 + 576*m.b10*m.b14*m.b28*
m.b32 + 512*m.b10*m.b14*m.b29*m.b33 + 448*m.b10*m.b14*m.b30*m.b34 + 384*m.b10*m.b14*m.b31*m.b35
+ 320*m.b10*m.b14*m.b32*m.b36 + 256*m.b10*m.b14*m.b33*m.b37 + 192*m.b10*m.b14*m.b34*m.b38 + 128*
m.b10*m.b14*m.b35*m.b39 + 64*m.b10*m.b14*m.b36*m.b40 + 64*m.b10*m.b15*m.b16*m.b21 + 64*m.b10*
m.b15*m.b17*m.b22 + 64*m.b10*m.b15*m.b18*m.b23 + 64*m.b10*m.b15*m.b19*m.b24 + 64*m.b10*m.b15*
m.b20*m.b25 + 640*m.b10*m.b15*m.b21*m.b26 + 640*m.b10*m.b15*m.b22*m.b27 + 640*m.b10*m.b15*m.b23*
m.b28 + 640*m.b10*m.b15*m.b24*m.b29 + 640*m.b10*m.b15*m.b25*m.b30 + 640*m.b10*m.b15*m.b26*m.b31
+ 576*m.b10*m.b15*m.b27*m.b32 + 512*m.b10*m.b15*m.b28*m.b33 + 448*m.b10*m.b15*m.b29*m.b34 + 384*
m.b10*m.b15*m.b30*m.b35 + 320*m.b10*m.b15*m.b31*m.b36 + 256*m.b10*m.b15*m.b32*m.b37 + 192*m.b10*
m.b15*m.b33*m.b38 + 128*m.b10*m.b15*m.b34*m.b39 + 64*m.b10*m.b15*m.b35*m.b40 + 64*m.b10*m.b16*
m.b17*m.b23 + 64*m.b10*m.b16*m.b18*m.b24 + 64*m.b10*m.b16*m.b19*m.b25 + 640*m.b10*m.b16*m.b20*
m.b26 + 640*m.b10*m.b16*m.b21*m.b27 + 640*m.b10*m.b16*m.b22*m.b28 + 640*m.b10*m.b16*m.b23*m.b29
+ 640*m.b10*m.b16*m.b24*m.b30 + 640*m.b10*m.b16*m.b25*m.b31 + 576*m.b10*m.b16*m.b26*m.b32 + 512*
m.b10*m.b16*m.b27*m.b33 + 448*m.b10*m.b16*m.b28*m.b34 + 384*m.b10*m.b16*m.b29*m.b35 + 320*m.b10*
m.b16*m.b30*m.b36 + 256*m.b10*m.b16*m.b31*m.b37 + 192*m.b10*m.b16*m.b32*m.b38 + 128*m.b10*m.b16*
m.b33*m.b39 + 64*m.b10*m.b16*m.b34*m.b40 + 64*m.b10*m.b17*m.b18*m.b25 + 640*m.b10*m.b17*m.b19*
m.b26 + 640*m.b10*m.b17*m.b20*m.b27 + 640*m.b10*m.b17*m.b21*m.b28 + 640*m.b10*m.b17*m.b22*m.b29
+ 640*m.b10*m.b17*m.b23*m.b30 + 640*m.b10*m.b17*m.b24*m.b31 + 576*m.b10*m.b17*m.b25*m.b32 + 512*
m.b10*m.b17*m.b26*m.b33 + 448*m.b10*m.b17*m.b27*m.b34 + 384*m.b10*m.b17*m.b28*m.b35 + 320*m.b10*
m.b17*m.b29*m.b36 + 256*m.b10*m.b17*m.b30*m.b37 + 192*m.b10*m.b17*m.b31*m.b38 + 128*m.b10*m.b17*
m.b32*m.b39 + 64*m.b10*m.b17*m.b33*m.b40 + 640*m.b10*m.b18*m.b19*m.b27 + 640*m.b10*m.b18*m.b20*
m.b28 + 640*m.b10*m.b18*m.b21*m.b29 + 640*m.b10*m.b18*m.b22*m.b30 + 640*m.b10*m.b18*m.b23*m.b31
+ 576*m.b10*m.b18*m.b24*m.b32 + 512*m.b10*m.b18*m.b25*m.b33 + 448*m.b10*m.b18*m.b26*m.b34 + 384*
m.b10*m.b18*m.b27*m.b35 + 320*m.b10*m.b18*m.b28*m.b36 + 256*m.b10*m.b18*m.b29*m.b37 + 192*m.b10*
m.b18*m.b30*m.b38 + 128*m.b10*m.b18*m.b31*m.b39 + 64*m.b10*m.b18*m.b32*m.b40 + 640*m.b10*m.b19*
m.b20*m.b29 + 640*m.b10*m.b19*m.b21*m.b30 + 640*m.b10*m.b19*m.b22*m.b31 + 576*m.b10*m.b19*m.b23*
m.b32 + 512*m.b10*m.b19*m.b24*m.b33 + 448*m.b10*m.b19*m.b25*m.b34 + 384*m.b10*m.b19*m.b26*m.b35
+ 320*m.b10*m.b19*m.b27*m.b36 + 256*m.b10*m.b19*m.b28*m.b37 + 192*m.b10*m.b19*m.b29*m.b38 + 128*
m.b10*m.b19*m.b30*m.b39 + 64*m.b10*m.b19*m.b31*m.b40 + 640*m.b10*m.b20*m.b21*m.b31 + 576*m.b10*
m.b20*m.b22*m.b32 + 512*m.b10*m.b20*m.b23*m.b33 + 448*m.b10*m.b20*m.b24*m.b34 + 384*m.b10*m.b20*
m.b25*m.b35 + 320*m.b10*m.b20*m.b26*m.b36 + 256*m.b10*m.b20*m.b27*m.b37 + 192*m.b10*m.b20*m.b28*
m.b38 + 128*m.b10*m.b20*m.b29*m.b39 + 64*m.b10*m.b20*m.b30*m.b40 + 512*m.b10*m.b21*m.b22*m.b33 +
448*m.b10*m.b21*m.b23*m.b34 + 384*m.b10*m.b21*m.b24*m.b35 + 320*m.b10*m.b21*m.b25*m.b36 + 256*
m.b10*m.b21*m.b26*m.b37 + 192*m.b10*m.b21*m.b27*m.b38 + 128*m.b10*m.b21*m.b28*m.b39 + 64*m.b10*
m.b21*m.b29*m.b40 + 384*m.b10*m.b22*m.b23*m.b35 + 320*m.b10*m.b22*m.b24*m.b36 + 256*m.b10*m.b22*
m.b25*m.b37 + 192*m.b10*m.b22*m.b26*m.b38 + 128*m.b10*m.b22*m.b27*m.b39 + 64*m.b10*m.b22*m.b28*
m.b40 + 256*m.b10*m.b23*m.b24*m.b37 + 192*m.b10*m.b23*m.b25*m.b38 + 128*m.b10*m.b23*m.b26*m.b39
+ 64*m.b10*m.b23*m.b27*m.b40 + 128*m.b10*m.b24*m.b25*m.b39 + 64*m.b10*m.b24*m.b26*m.b40 + 64*
m.b11*m.b12*m.b13*m.b14 + 64*m.b11*m.b12*m.b14*m.b15 + 64*m.b11*m.b12*m.b15*m.b16 + 64*m.b11*
m.b12*m.b16*m.b17 + 64*m.b11*m.b12*m.b17*m.b18 + 64*m.b11*m.b12*m.b18*m.b19 + 64*m.b11*m.b12*
m.b19*m.b20 + 64*m.b11*m.b12*m.b20*m.b21 + 64*m.b11*m.b12*m.b21*m.b22 + 64*m.b11*m.b12*m.b22*
m.b23 + 64*m.b11*m.b12*m.b23*m.b24 + 64*m.b11*m.b12*m.b24*m.b25 + 64*m.b11*m.b12*m.b25*m.b26 +
704*m.b11*m.b12*m.b26*m.b27 + 704*m.b11*m.b12*m.b27*m.b28 + 704*m.b11*m.b12*m.b28*m.b29 + 704*
m.b11*m.b12*m.b29*m.b30 + 640*m.b11*m.b12*m.b30*m.b31 + 576*m.b11*m.b12*m.b31*m.b32 + 512*m.b11*
m.b12*m.b32*m.b33 + 448*m.b11*m.b12*m.b33*m.b34 + 384*m.b11*m.b12*m.b34*m.b35 + 320*m.b11*m.b12*
m.b35*m.b36 + 256*m.b11*m.b12*m.b36*m.b37 + 192*m.b11*m.b12*m.b37*m.b38 + 128*m.b11*m.b12*m.b38*
m.b39 + 64*m.b11*m.b12*m.b39*m.b40 + 64*m.b11*m.b13*m.b14*m.b16 + 64*m.b11*m.b13*m.b15*m.b17 + 64
*m.b11*m.b13*m.b16*m.b18 + 64*m.b11*m.b13*m.b17*m.b19 + 64*m.b11*m.b13*m.b18*m.b20 + 64*m.b11*
m.b13*m.b19*m.b21 + 64*m.b11*m.b13*m.b20*m.b22 + 64*m.b11*m.b13*m.b21*m.b23 + 64*m.b11*m.b13*
m.b22*m.b24 + 64*m.b11*m.b13*m.b23*m.b25 + 64*m.b11*m.b13*m.b24*m.b26 + 704*m.b11*m.b13*m.b25*
m.b27 + 704*m.b11*m.b13*m.b26*m.b28 + 704*m.b11*m.b13*m.b27*m.b29 + 704*m.b11*m.b13*m.b28*m.b30
+ 640*m.b11*m.b13*m.b29*m.b31 + 576*m.b11*m.b13*m.b30*m.b32 + 512*m.b11*m.b13*m.b31*m.b33 + 448*
m.b11*m.b13*m.b32*m.b34 + 384*m.b11*m.b13*m.b33*m.b35 + 320*m.b11*m.b13*m.b34*m.b36 + 256*m.b11*
m.b13*m.b35*m.b37 + 192*m.b11*m.b13*m.b36*m.b38 + 128*m.b11*m.b13*m.b37*m.b39 + 64*m.b11*m.b13*
m.b38*m.b40 + 64*m.b11*m.b14*m.b15*m.b18 + 64*m.b11*m.b14*m.b16*m.b19 + 64*m.b11*m.b14*m.b17*
m.b20 + 64*m.b11*m.b14*m.b18*m.b21 + 64*m.b11*m.b14*m.b19*m.b22 + 64*m.b11*m.b14*m.b20*m.b23 + 64
*m.b11*m.b14*m.b21*m.b24 + 64*m.b11*m.b14*m.b22*m.b25 + 64*m.b11*m.b14*m.b23*m.b26 + 704*m.b11*
m.b14*m.b24*m.b27 + 704*m.b11*m.b14*m.b25*m.b28 + 704*m.b11*m.b14*m.b26*m.b29 + 704*m.b11*m.b14*
m.b27*m.b30 + 640*m.b11*m.b14*m.b28*m.b31 + 576*m.b11*m.b14*m.b29*m.b32 + 512*m.b11*m.b14*m.b30*
m.b33 + 448*m.b11*m.b14*m.b31*m.b34 + 384*m.b11*m.b14*m.b32*m.b35 + 320*m.b11*m.b14*m.b33*m.b36
+ 256*m.b11*m.b14*m.b34*m.b37 + 192*m.b11*m.b14*m.b35*m.b38 + 128*m.b11*m.b14*m.b36*m.b39 + 64*
m.b11*m.b14*m.b37*m.b40 + 64*m.b11*m.b15*m.b16*m.b20 + 64*m.b11*m.b15*m.b17*m.b21 + 64*m.b11*
m.b15*m.b18*m.b22 + 64*m.b11*m.b15*m.b19*m.b23 + 64*m.b11*m.b15*m.b20*m.b24 + 64*m.b11*m.b15*
m.b21*m.b25 + 64*m.b11*m.b15*m.b22*m.b26 + 704*m.b11*m.b15*m.b23*m.b27 + 704*m.b11*m.b15*m.b24*
m.b28 + 704*m.b11*m.b15*m.b25*m.b29 + 704*m.b11*m.b15*m.b26*m.b30 + 640*m.b11*m.b15*m.b27*m.b31
+ 576*m.b11*m.b15*m.b28*m.b32 + 512*m.b11*m.b15*m.b29*m.b33 + 448*m.b11*m.b15*m.b30*m.b34 + 384*
m.b11*m.b15*m.b31*m.b35 + 320*m.b11*m.b15*m.b32*m.b36 + 256*m.b11*m.b15*m.b33*m.b37 + 192*m.b11*
m.b15*m.b34*m.b38 + 128*m.b11*m.b15*m.b35*m.b39 + 64*m.b11*m.b15*m.b36*m.b40 + 64*m.b11*m.b16*
m.b17*m.b22 + 64*m.b11*m.b16*m.b18*m.b23 + 64*m.b11*m.b16*m.b19*m.b24 + 64*m.b11*m.b16*m.b20*
m.b25 + 64*m.b11*m.b16*m.b21*m.b26 + 704*m.b11*m.b16*m.b22*m.b27 + 704*m.b11*m.b16*m.b23*m.b28 +
704*m.b11*m.b16*m.b24*m.b29 + 704*m.b11*m.b16*m.b25*m.b30 + 640*m.b11*m.b16*m.b26*m.b31 + 576*
m.b11*m.b16*m.b27*m.b32 + 512*m.b11*m.b16*m.b28*m.b33 + 448*m.b11*m.b16*m.b29*m.b34 + 384*m.b11*
m.b16*m.b30*m.b35 + 320*m.b11*m.b16*m.b31*m.b36 + 256*m.b11*m.b16*m.b32*m.b37 + 192*m.b11*m.b16*
m.b33*m.b38 + 128*m.b11*m.b16*m.b34*m.b39 + 64*m.b11*m.b16*m.b35*m.b40 + 64*m.b11*m.b17*m.b18*
m.b24 + 64*m.b11*m.b17*m.b19*m.b25 + 64*m.b11*m.b17*m.b20*m.b26 + 704*m.b11*m.b17*m.b21*m.b27 +
704*m.b11*m.b17*m.b22*m.b28 + 704*m.b11*m.b17*m.b23*m.b29 + 704*m.b11*m.b17*m.b24*m.b30 + 640*
m.b11*m.b17*m.b25*m.b31 + 576*m.b11*m.b17*m.b26*m.b32 + 512*m.b11*m.b17*m.b27*m.b33 + 448*m.b11*
m.b17*m.b28*m.b34 + 384*m.b11*m.b17*m.b29*m.b35 + 320*m.b11*m.b17*m.b30*m.b36 + 256*m.b11*m.b17*
m.b31*m.b37 + 192*m.b11*m.b17*m.b32*m.b38 + 128*m.b11*m.b17*m.b33*m.b39 + 64*m.b11*m.b17*m.b34*
m.b40 + 64*m.b11*m.b18*m.b19*m.b26 + 704*m.b11*m.b18*m.b20*m.b27 + 704*m.b11*m.b18*m.b21*m.b28 +
704*m.b11*m.b18*m.b22*m.b29 + 704*m.b11*m.b18*m.b23*m.b30 + 640*m.b11*m.b18*m.b24*m.b31 + 576*
m.b11*m.b18*m.b25*m.b32 + 512*m.b11*m.b18*m.b26*m.b33 + 448*m.b11*m.b18*m.b27*m.b34 + 384*m.b11*
m.b18*m.b28*m.b35 + 320*m.b11*m.b18*m.b29*m.b36 + 256*m.b11*m.b18*m.b30*m.b37 + 192*m.b11*m.b18*
m.b31*m.b38 + 128*m.b11*m.b18*m.b32*m.b39 + 64*m.b11*m.b18*m.b33*m.b40 + 704*m.b11*m.b19*m.b20*
m.b28 + 704*m.b11*m.b19*m.b21*m.b29 + 704*m.b11*m.b19*m.b22*m.b30 + 640*m.b11*m.b19*m.b23*m.b31
+ 576*m.b11*m.b19*m.b24*m.b32 + 512*m.b11*m.b19*m.b25*m.b33 + 448*m.b11*m.b19*m.b26*m.b34 + 384*
m.b11*m.b19*m.b27*m.b35 + 320*m.b11*m.b19*m.b28*m.b36 + 256*m.b11*m.b19*m.b29*m.b37 + 192*m.b11*
m.b19*m.b30*m.b38 + 128*m.b11*m.b19*m.b31*m.b39 + 64*m.b11*m.b19*m.b32*m.b40 + 704*m.b11*m.b20*
m.b21*m.b30 + 640*m.b11*m.b20*m.b22*m.b31 + 576*m.b11*m.b20*m.b23*m.b32 + 512*m.b11*m.b20*m.b24*
m.b33 + 448*m.b11*m.b20*m.b25*m.b34 + 384*m.b11*m.b20*m.b26*m.b35 + 320*m.b11*m.b20*m.b27*m.b36
+ 256*m.b11*m.b20*m.b28*m.b37 + 192*m.b11*m.b20*m.b29*m.b38 + 128*m.b11*m.b20*m.b30*m.b39 + 64*
m.b11*m.b20*m.b31*m.b40 + 576*m.b11*m.b21*m.b22*m.b32 + 512*m.b11*m.b21*m.b23*m.b33 + 448*m.b11*
m.b21*m.b24*m.b34 + 384*m.b11*m.b21*m.b25*m.b35 + 320*m.b11*m.b21*m.b26*m.b36 + 256*m.b11*m.b21*
m.b27*m.b37 + 192*m.b11*m.b21*m.b28*m.b38 + 128*m.b11*m.b21*m.b29*m.b39 + 64*m.b11*m.b21*m.b30*
m.b40 + 448*m.b11*m.b22*m.b23*m.b34 + 384*m.b11*m.b22*m.b24*m.b35 + 320*m.b11*m.b22*m.b25*m.b36
+ 256*m.b11*m.b22*m.b26*m.b37 + 192*m.b11*m.b22*m.b27*m.b38 + 128*m.b11*m.b22*m.b28*m.b39 + 64*
m.b11*m.b22*m.b29*m.b40 + 320*m.b11*m.b23*m.b24*m.b36 + 256*m.b11*m.b23*m.b25*m.b37 + 192*m.b11*
m.b23*m.b26*m.b38 + 128*m.b11*m.b23*m.b27*m.b39 + 64*m.b11*m.b23*m.b28*m.b40 + 192*m.b11*m.b24*
m.b25*m.b38 + 128*m.b11*m.b24*m.b26*m.b39 + 64*m.b11*m.b24*m.b27*m.b40 + 64*m.b11*m.b25*m.b26*
m.b40 + 64*m.b12*m.b13*m.b14*m.b15 + 64*m.b12*m.b13*m.b15*m.b16 + 64*m.b12*m.b13*m.b16*m.b17 + 64
*m.b12*m.b13*m.b17*m.b18 + 64*m.b12*m.b13*m.b18*m.b19 + 64*m.b12*m.b13*m.b19*m.b20 + 64*m.b12*
m.b13*m.b20*m.b21 + 64*m.b12*m.b13*m.b21*m.b22 + 64*m.b12*m.b13*m.b22*m.b23 + 64*m.b12*m.b13*
m.b23*m.b24 + 64*m.b12*m.b13*m.b24*m.b25 + 64*m.b12*m.b13*m.b25*m.b26 + 64*m.b12*m.b13*m.b26*
m.b27 + 768*m.b12*m.b13*m.b27*m.b28 + 768*m.b12*m.b13*m.b28*m.b29 + 704*m.b12*m.b13*m.b29*m.b30
+ 640*m.b12*m.b13*m.b30*m.b31 + 576*m.b12*m.b13*m.b31*m.b32 + 512*m.b12*m.b13*m.b32*m.b33 + 448*
m.b12*m.b13*m.b33*m.b34 + 384*m.b12*m.b13*m.b34*m.b35 + 320*m.b12*m.b13*m.b35*m.b36 + 256*m.b12*
m.b13*m.b36*m.b37 + 192*m.b12*m.b13*m.b37*m.b38 + 128*m.b12*m.b13*m.b38*m.b39 + 64*m.b12*m.b13*
m.b39*m.b40 + 64*m.b12*m.b14*m.b15*m.b17 + 64*m.b12*m.b14*m.b16*m.b18 + 64*m.b12*m.b14*m.b17*
m.b19 + 64*m.b12*m.b14*m.b18*m.b20 + 64*m.b12*m.b14*m.b19*m.b21 + 64*m.b12*m.b14*m.b20*m.b22 + 64
*m.b12*m.b14*m.b21*m.b23 + 64*m.b12*m.b14*m.b22*m.b24 + 64*m.b12*m.b14*m.b23*m.b25 + 64*m.b12*
m.b14*m.b24*m.b26 + 64*m.b12*m.b14*m.b25*m.b27 + 768*m.b12*m.b14*m.b26*m.b28 + 768*m.b12*m.b14*
m.b27*m.b29 + 704*m.b12*m.b14*m.b28*m.b30 + 640*m.b12*m.b14*m.b29*m.b31 + 576*m.b12*m.b14*m.b30*
m.b32 + 512*m.b12*m.b14*m.b31*m.b33 + 448*m.b12*m.b14*m.b32*m.b34 + 384*m.b12*m.b14*m.b33*m.b35
+ 320*m.b12*m.b14*m.b34*m.b36 + 256*m.b12*m.b14*m.b35*m.b37 + 192*m.b12*m.b14*m.b36*m.b38 + 128*
m.b12*m.b14*m.b37*m.b39 + 64*m.b12*m.b14*m.b38*m.b40 + 64*m.b12*m.b15*m.b16*m.b19 + 64*m.b12*
m.b15*m.b17*m.b20 + 64*m.b12*m.b15*m.b18*m.b21 + 64*m.b12*m.b15*m.b19*m.b22 + 64*m.b12*m.b15*
m.b20*m.b23 + 64*m.b12*m.b15*m.b21*m.b24 + 64*m.b12*m.b15*m.b22*m.b25 + 64*m.b12*m.b15*m.b23*
m.b26 + 64*m.b12*m.b15*m.b24*m.b27 + 768*m.b12*m.b15*m.b25*m.b28 + 768*m.b12*m.b15*m.b26*m.b29 +
704*m.b12*m.b15*m.b27*m.b30 + 640*m.b12*m.b15*m.b28*m.b31 + 576*m.b12*m.b15*m.b29*m.b32 + 512*
m.b12*m.b15*m.b30*m.b33 + 448*m.b12*m.b15*m.b31*m.b34 + 384*m.b12*m.b15*m.b32*m.b35 + 320*m.b12*
m.b15*m.b33*m.b36 + 256*m.b12*m.b15*m.b34*m.b37 + 192*m.b12*m.b15*m.b35*m.b38 + 128*m.b12*m.b15*
m.b36*m.b39 + 64*m.b12*m.b15*m.b37*m.b40 + 64*m.b12*m.b16*m.b17*m.b21 + 64*m.b12*m.b16*m.b18*
m.b22 + 64*m.b12*m.b16*m.b19*m.b23 + 64*m.b12*m.b16*m.b20*m.b24 + 64*m.b12*m.b16*m.b21*m.b25 + 64
*m.b12*m.b16*m.b22*m.b26 + 64*m.b12*m.b16*m.b23*m.b27 + 768*m.b12*m.b16*m.b24*m.b28 + 768*m.b12*
m.b16*m.b25*m.b29 + 704*m.b12*m.b16*m.b26*m.b30 + 640*m.b12*m.b16*m.b27*m.b31 + 576*m.b12*m.b16*
m.b28*m.b32 + 512*m.b12*m.b16*m.b29*m.b33 + 448*m.b12*m.b16*m.b30*m.b34 + 384*m.b12*m.b16*m.b31*
m.b35 + 320*m.b12*m.b16*m.b32*m.b36 + 256*m.b12*m.b16*m.b33*m.b37 + 192*m.b12*m.b16*m.b34*m.b38
+ 128*m.b12*m.b16*m.b35*m.b39 + 64*m.b12*m.b16*m.b36*m.b40 + 64*m.b12*m.b17*m.b18*m.b23 + 64*
m.b12*m.b17*m.b19*m.b24 + 64*m.b12*m.b17*m.b20*m.b25 + 64*m.b12*m.b17*m.b21*m.b26 + 64*m.b12*
m.b17*m.b22*m.b27 + 768*m.b12*m.b17*m.b23*m.b28 + 768*m.b12*m.b17*m.b24*m.b29 + 704*m.b12*m.b17*
m.b25*m.b30 + 640*m.b12*m.b17*m.b26*m.b31 + 576*m.b12*m.b17*m.b27*m.b32 + 512*m.b12*m.b17*m.b28*
m.b33 + 448*m.b12*m.b17*m.b29*m.b34 + 384*m.b12*m.b17*m.b30*m.b35 + 320*m.b12*m.b17*m.b31*m.b36
+ 256*m.b12*m.b17*m.b32*m.b37 + 192*m.b12*m.b17*m.b33*m.b38 + 128*m.b12*m.b17*m.b34*m.b39 + 64*
m.b12*m.b17*m.b35*m.b40 + 64*m.b12*m.b18*m.b19*m.b25 + 64*m.b12*m.b18*m.b20*m.b26 + 64*m.b12*
m.b18*m.b21*m.b27 + 768*m.b12*m.b18*m.b22*m.b28 + 768*m.b12*m.b18*m.b23*m.b29 + 704*m.b12*m.b18*
m.b24*m.b30 + 640*m.b12*m.b18*m.b25*m.b31 + 576*m.b12*m.b18*m.b26*m.b32 + 512*m.b12*m.b18*m.b27*
m.b33 + 448*m.b12*m.b18*m.b28*m.b34 + 384*m.b12*m.b18*m.b29*m.b35 + 320*m.b12*m.b18*m.b30*m.b36
+ 256*m.b12*m.b18*m.b31*m.b37 + 192*m.b12*m.b18*m.b32*m.b38 + 128*m.b12*m.b18*m.b33*m.b39 + 64*
m.b12*m.b18*m.b34*m.b40 + 64*m.b12*m.b19*m.b20*m.b27 + 768*m.b12*m.b19*m.b21*m.b28 + 768*m.b12*
m.b19*m.b22*m.b29 + 704*m.b12*m.b19*m.b23*m.b30 + 640*m.b12*m.b19*m.b24*m.b31 + 576*m.b12*m.b19*
m.b25*m.b32 + 512*m.b12*m.b19*m.b26*m.b33 + 448*m.b12*m.b19*m.b27*m.b34 + 384*m.b12*m.b19*m.b28*
m.b35 + 320*m.b12*m.b19*m.b29*m.b36 + 256*m.b12*m.b19*m.b30*m.b37 + 192*m.b12*m.b19*m.b31*m.b38
+ 128*m.b12*m.b19*m.b32*m.b39 + 64*m.b12*m.b19*m.b33*m.b40 + 768*m.b12*m.b20*m.b21*m.b29 + 704*
m.b12*m.b20*m.b22*m.b30 + 640*m.b12*m.b20*m.b23*m.b31 + 576*m.b12*m.b20*m.b24*m.b32 + 512*m.b12*
m.b20*m.b25*m.b33 + 448*m.b12*m.b20*m.b26*m.b34 + 384*m.b12*m.b20*m.b27*m.b35 + 320*m.b12*m.b20*
m.b28*m.b36 + 256*m.b12*m.b20*m.b29*m.b37 + 192*m.b12*m.b20*m.b30*m.b38 + 128*m.b12*m.b20*m.b31*
m.b39 + 64*m.b12*m.b20*m.b32*m.b40 + 640*m.b12*m.b21*m.b22*m.b31 + 576*m.b12*m.b21*m.b23*m.b32 +
512*m.b12*m.b21*m.b24*m.b33 + 448*m.b12*m.b21*m.b25*m.b34 + 384*m.b12*m.b21*m.b26*m.b35 + 320*
m.b12*m.b21*m.b27*m.b36 + 256*m.b12*m.b21*m.b28*m.b37 + 192*m.b12*m.b21*m.b29*m.b38 + 128*m.b12*
m.b21*m.b30*m.b39 + 64*m.b12*m.b21*m.b31*m.b40 + 512*m.b12*m.b22*m.b23*m.b33 + 448*m.b12*m.b22*
m.b24*m.b34 + 384*m.b12*m.b22*m.b25*m.b35 + 320*m.b12*m.b22*m.b26*m.b36 + 256*m.b12*m.b22*m.b27*
m.b37 + 192*m.b12*m.b22*m.b28*m.b38 + 128*m.b12*m.b22*m.b29*m.b39 + 64*m.b12*m.b22*m.b30*m.b40 +
384*m.b12*m.b23*m.b24*m.b35 + 320*m.b12*m.b23*m.b25*m.b36 + 256*m.b12*m.b23*m.b26*m.b37 + 192*
m.b12*m.b23*m.b27*m.b38 + 128*m.b12*m.b23*m.b28*m.b39 + 64*m.b12*m.b23*m.b29*m.b40 + 256*m.b12*
m.b24*m.b25*m.b37 + 192*m.b12*m.b24*m.b26*m.b38 + 128*m.b12*m.b24*m.b27*m.b39 + 64*m.b12*m.b24*
m.b28*m.b40 + 128*m.b12*m.b25*m.b26*m.b39 + 64*m.b12*m.b25*m.b27*m.b40 + 64*m.b13*m.b14*m.b15*
m.b16 + 64*m.b13*m.b14*m.b16*m.b17 + 64*m.b13*m.b14*m.b17*m.b18 + 64*m.b13*m.b14*m.b18*m.b19 + 64
*m.b13*m.b14*m.b19*m.b20 + 64*m.b13*m.b14*m.b20*m.b21 + 64*m.b13*m.b14*m.b21*m.b22 + 64*m.b13*
m.b14*m.b22*m.b23 + 64*m.b13*m.b14*m.b23*m.b24 + 64*m.b13*m.b14*m.b24*m.b25 + 64*m.b13*m.b14*
m.b25*m.b26 + 64*m.b13*m.b14*m.b26*m.b27 + 64*m.b13*m.b14*m.b27*m.b28 + 768*m.b13*m.b14*m.b28*
m.b29 + 704*m.b13*m.b14*m.b29*m.b30 + 640*m.b13*m.b14*m.b30*m.b31 + 576*m.b13*m.b14*m.b31*m.b32
+ 512*m.b13*m.b14*m.b32*m.b33 + 448*m.b13*m.b14*m.b33*m.b34 + 384*m.b13*m.b14*m.b34*m.b35 + 320*
m.b13*m.b14*m.b35*m.b36 + 256*m.b13*m.b14*m.b36*m.b37 + 192*m.b13*m.b14*m.b37*m.b38 + 128*m.b13*
m.b14*m.b38*m.b39 + 64*m.b13*m.b14*m.b39*m.b40 + 64*m.b13*m.b15*m.b16*m.b18 + 64*m.b13*m.b15*
m.b17*m.b19 + 64*m.b13*m.b15*m.b18*m.b20 + 64*m.b13*m.b15*m.b19*m.b21 + 64*m.b13*m.b15*m.b20*
m.b22 + 64*m.b13*m.b15*m.b21*m.b23 + 64*m.b13*m.b15*m.b22*m.b24 + 64*m.b13*m.b15*m.b23*m.b25 + 64
*m.b13*m.b15*m.b24*m.b26 + 64*m.b13*m.b15*m.b25*m.b27 + 64*m.b13*m.b15*m.b26*m.b28 + 768*m.b13*
m.b15*m.b27*m.b29 + 704*m.b13*m.b15*m.b28*m.b30 + 640*m.b13*m.b15*m.b29*m.b31 + 576*m.b13*m.b15*
m.b30*m.b32 + 512*m.b13*m.b15*m.b31*m.b33 + 448*m.b13*m.b15*m.b32*m.b34 + 384*m.b13*m.b15*m.b33*
m.b35 + 320*m.b13*m.b15*m.b34*m.b36 + 256*m.b13*m.b15*m.b35*m.b37 + 192*m.b13*m.b15*m.b36*m.b38
+ 128*m.b13*m.b15*m.b37*m.b39 + 64*m.b13*m.b15*m.b38*m.b40 + 64*m.b13*m.b16*m.b17*m.b20 + 64*
m.b13*m.b16*m.b18*m.b21 + 64*m.b13*m.b16*m.b19*m.b22 + 64*m.b13*m.b16*m.b20*m.b23 + 64*m.b13*
m.b16*m.b21*m.b24 + 64*m.b13*m.b16*m.b22*m.b25 + 64*m.b13*m.b16*m.b23*m.b26 + 64*m.b13*m.b16*
m.b24*m.b27 + 64*m.b13*m.b16*m.b25*m.b28 + 768*m.b13*m.b16*m.b26*m.b29 + 704*m.b13*m.b16*m.b27*
m.b30 + 640*m.b13*m.b16*m.b28*m.b31 + 576*m.b13*m.b16*m.b29*m.b32 + 512*m.b13*m.b16*m.b30*m.b33
+ 448*m.b13*m.b16*m.b31*m.b34 + 384*m.b13*m.b16*m.b32*m.b35 + 320*m.b13*m.b16*m.b33*m.b36 + 256*
m.b13*m.b16*m.b34*m.b37 + 192*m.b13*m.b16*m.b35*m.b38 + 128*m.b13*m.b16*m.b36*m.b39 + 64*m.b13*
m.b16*m.b37*m.b40 + 64*m.b13*m.b17*m.b18*m.b22 + 64*m.b13*m.b17*m.b19*m.b23 + 64*m.b13*m.b17*
m.b20*m.b24 + 64*m.b13*m.b17*m.b21*m.b25 + 64*m.b13*m.b17*m.b22*m.b26 + 64*m.b13*m.b17*m.b23*
m.b27 + 64*m.b13*m.b17*m.b24*m.b28 + 768*m.b13*m.b17*m.b25*m.b29 + 704*m.b13*m.b17*m.b26*m.b30 +
640*m.b13*m.b17*m.b27*m.b31 + 576*m.b13*m.b17*m.b28*m.b32 + 512*m.b13*m.b17*m.b29*m.b33 + 448*
m.b13*m.b17*m.b30*m.b34 + 384*m.b13*m.b17*m.b31*m.b35 + 320*m.b13*m.b17*m.b32*m.b36 + 256*m.b13*
m.b17*m.b33*m.b37 + 192*m.b13*m.b17*m.b34*m.b38 + 128*m.b13*m.b17*m.b35*m.b39 + 64*m.b13*m.b17*
m.b36*m.b40 + 64*m.b13*m.b18*m.b19*m.b24 + 64*m.b13*m.b18*m.b20*m.b25 + 64*m.b13*m.b18*m.b21*
m.b26 + 64*m.b13*m.b18*m.b22*m.b27 + 64*m.b13*m.b18*m.b23*m.b28 + 768*m.b13*m.b18*m.b24*m.b29 +
704*m.b13*m.b18*m.b25*m.b30 + 640*m.b13*m.b18*m.b26*m.b31 + 576*m.b13*m.b18*m.b27*m.b32 + 512*
m.b13*m.b18*m.b28*m.b33 + 448*m.b13*m.b18*m.b29*m.b34 + 384*m.b13*m.b18*m.b30*m.b35 + 320*m.b13*
m.b18*m.b31*m.b36 + 256*m.b13*m.b18*m.b32*m.b37 + 192*m.b13*m.b18*m.b33*m.b38 + 128*m.b13*m.b18*
m.b34*m.b39 + 64*m.b13*m.b18*m.b35*m.b40 + 64*m.b13*m.b19*m.b20*m.b26 + 64*m.b13*m.b19*m.b21*
m.b27 + 64*m.b13*m.b19*m.b22*m.b28 + 768*m.b13*m.b19*m.b23*m.b29 + 704*m.b13*m.b19*m.b24*m.b30 +
640*m.b13*m.b19*m.b25*m.b31 + 576*m.b13*m.b19*m.b26*m.b32 + 512*m.b13*m.b19*m.b27*m.b33 + 448*
m.b13*m.b19*m.b28*m.b34 + 384*m.b13*m.b19*m.b29*m.b35 + 320*m.b13*m.b19*m.b30*m.b36 + 256*m.b13*
m.b19*m.b31*m.b37 + 192*m.b13*m.b19*m.b32*m.b38 + 128*m.b13*m.b19*m.b33*m.b39 + 64*m.b13*m.b19*
m.b34*m.b40 + 64*m.b13*m.b20*m.b21*m.b28 + 768*m.b13*m.b20*m.b22*m.b29 + 704*m.b13*m.b20*m.b23*
m.b30 + 640*m.b13*m.b20*m.b24*m.b31 + 576*m.b13*m.b20*m.b25*m.b32 + 512*m.b13*m.b20*m.b26*m.b33
+ 448*m.b13*m.b20*m.b27*m.b34 + 384*m.b13*m.b20*m.b28*m.b35 + 320*m.b13*m.b20*m.b29*m.b36 + 256*
m.b13*m.b20*m.b30*m.b37 + 192*m.b13*m.b20*m.b31*m.b38 + 128*m.b13*m.b20*m.b32*m.b39 + 64*m.b13*
m.b20*m.b33*m.b40 + 704*m.b13*m.b21*m.b22*m.b30 + 640*m.b13*m.b21*m.b23*m.b31 + 576*m.b13*m.b21*
m.b24*m.b32 + 512*m.b13*m.b21*m.b25*m.b33 + 448*m.b13*m.b21*m.b26*m.b34 + 384*m.b13*m.b21*m.b27*
m.b35 + 320*m.b13*m.b21*m.b28*m.b36 + 256*m.b13*m.b21*m.b29*m.b37 + 192*m.b13*m.b21*m.b30*m.b38
+ 128*m.b13*m.b21*m.b31*m.b39 + 64*m.b13*m.b21*m.b32*m.b40 + 576*m.b13*m.b22*m.b23*m.b32 + 512*
m.b13*m.b22*m.b24*m.b33 + 448*m.b13*m.b22*m.b25*m.b34 + 384*m.b13*m.b22*m.b26*m.b35 + 320*m.b13*
m.b22*m.b27*m.b36 + 256*m.b13*m.b22*m.b28*m.b37 + 192*m.b13*m.b22*m.b29*m.b38 + 128*m.b13*m.b22*
m.b30*m.b39 + 64*m.b13*m.b22*m.b31*m.b40 + 448*m.b13*m.b23*m.b24*m.b34 + 384*m.b13*m.b23*m.b25*
m.b35 + 320*m.b13*m.b23*m.b26*m.b36 + 256*m.b13*m.b23*m.b27*m.b37 + 192*m.b13*m.b23*m.b28*m.b38
+ 128*m.b13*m.b23*m.b29*m.b39 + 64*m.b13*m.b23*m.b30*m.b40 + 320*m.b13*m.b24*m.b25*m.b36 + 256*
m.b13*m.b24*m.b26*m.b37 + 192*m.b13*m.b24*m.b27*m.b38 + 128*m.b13*m.b24*m.b28*m.b39 + 64*m.b13*
m.b24*m.b29*m.b40 + 192*m.b13*m.b25*m.b26*m.b38 + 128*m.b13*m.b25*m.b27*m.b39 + 64*m.b13*m.b25*
m.b28*m.b40 + 64*m.b13*m.b26*m.b27*m.b40 + 64*m.b14*m.b15*m.b16*m.b17 + 64*m.b14*m.b15*m.b17*
m.b18 + 64*m.b14*m.b15*m.b18*m.b19 + 64*m.b14*m.b15*m.b19*m.b20 + 64*m.b14*m.b15*m.b20*m.b21 + 64
*m.b14*m.b15*m.b21*m.b22 + 64*m.b14*m.b15*m.b22*m.b23 + 64*m.b14*m.b15*m.b23*m.b24 + 64*m.b14*
m.b15*m.b24*m.b25 + 64*m.b14*m.b15*m.b25*m.b26 + 64*m.b14*m.b15*m.b26*m.b27 + 64*m.b14*m.b15*
m.b27*m.b28 + 64*m.b14*m.b15*m.b28*m.b29 + 704*m.b14*m.b15*m.b29*m.b30 + 640*m.b14*m.b15*m.b30*
m.b31 + 576*m.b14*m.b15*m.b31*m.b32 + 512*m.b14*m.b15*m.b32*m.b33 + 448*m.b14*m.b15*m.b33*m.b34
+ 384*m.b14*m.b15*m.b34*m.b35 + 320*m.b14*m.b15*m.b35*m.b36 + 256*m.b14*m.b15*m.b36*m.b37 + 192*
m.b14*m.b15*m.b37*m.b38 + 128*m.b14*m.b15*m.b38*m.b39 + 64*m.b14*m.b15*m.b39*m.b40 + 64*m.b14*
m.b16*m.b17*m.b19 + 64*m.b14*m.b16*m.b18*m.b20 + 64*m.b14*m.b16*m.b19*m.b21 + 64*m.b14*m.b16*
m.b20*m.b22 + 64*m.b14*m.b16*m.b21*m.b23 + 64*m.b14*m.b16*m.b22*m.b24 + 64*m.b14*m.b16*m.b23*
m.b25 + 64*m.b14*m.b16*m.b24*m.b26 + 64*m.b14*m.b16*m.b25*m.b27 + 64*m.b14*m.b16*m.b26*m.b28 + 64
*m.b14*m.b16*m.b27*m.b29 + 704*m.b14*m.b16*m.b28*m.b30 + 640*m.b14*m.b16*m.b29*m.b31 + 576*m.b14*
m.b16*m.b30*m.b32 + 512*m.b14*m.b16*m.b31*m.b33 + 448*m.b14*m.b16*m.b32*m.b34 + 384*m.b14*m.b16*
m.b33*m.b35 + 320*m.b14*m.b16*m.b34*m.b36 + 256*m.b14*m.b16*m.b35*m.b37 + 192*m.b14*m.b16*m.b36*
m.b38 + 128*m.b14*m.b16*m.b37*m.b39 + 64*m.b14*m.b16*m.b38*m.b40 + 64*m.b14*m.b17*m.b18*m.b21 +
64*m.b14*m.b17*m.b19*m.b22 + 64*m.b14*m.b17*m.b20*m.b23 + 64*m.b14*m.b17*m.b21*m.b24 + 64*m.b14*
m.b17*m.b22*m.b25 + 64*m.b14*m.b17*m.b23*m.b26 + 64*m.b14*m.b17*m.b24*m.b27 + 64*m.b14*m.b17*
m.b25*m.b28 + 64*m.b14*m.b17*m.b26*m.b29 + 704*m.b14*m.b17*m.b27*m.b30 + 640*m.b14*m.b17*m.b28*
m.b31 + 576*m.b14*m.b17*m.b29*m.b32 + 512*m.b14*m.b17*m.b30*m.b33 + 448*m.b14*m.b17*m.b31*m.b34
+ 384*m.b14*m.b17*m.b32*m.b35 + 320*m.b14*m.b17*m.b33*m.b36 + 256*m.b14*m.b17*m.b34*m.b37 + 192*
m.b14*m.b17*m.b35*m.b38 + 128*m.b14*m.b17*m.b36*m.b39 + 64*m.b14*m.b17*m.b37*m.b40 + 64*m.b14*
m.b18*m.b19*m.b23 + 64*m.b14*m.b18*m.b20*m.b24 + 64*m.b14*m.b18*m.b21*m.b25 + 64*m.b14*m.b18*
m.b22*m.b26 + 64*m.b14*m.b18*m.b23*m.b27 + 64*m.b14*m.b18*m.b24*m.b28 + 64*m.b14*m.b18*m.b25*
m.b29 + 704*m.b14*m.b18*m.b26*m.b30 + 640*m.b14*m.b18*m.b27*m.b31 + 576*m.b14*m.b18*m.b28*m.b32
+ 512*m.b14*m.b18*m.b29*m.b33 + 448*m.b14*m.b18*m.b30*m.b34 + 384*m.b14*m.b18*m.b31*m.b35 + 320*
m.b14*m.b18*m.b32*m.b36 + 256*m.b14*m.b18*m.b33*m.b37 + 192*m.b14*m.b18*m.b34*m.b38 + 128*m.b14*
m.b18*m.b35*m.b39 + 64*m.b14*m.b18*m.b36*m.b40 + 64*m.b14*m.b19*m.b20*m.b25 + 64*m.b14*m.b19*
m.b21*m.b26 + 64*m.b14*m.b19*m.b22*m.b27 + 64*m.b14*m.b19*m.b23*m.b28 + 64*m.b14*m.b19*m.b24*
m.b29 + 704*m.b14*m.b19*m.b25*m.b30 + 640*m.b14*m.b19*m.b26*m.b31 + 576*m.b14*m.b19*m.b27*m.b32
+ 512*m.b14*m.b19*m.b28*m.b33 + 448*m.b14*m.b19*m.b29*m.b34 + 384*m.b14*m.b19*m.b30*m.b35 + 320*
m.b14*m.b19*m.b31*m.b36 + 256*m.b14*m.b19*m.b32*m.b37 + 192*m.b14*m.b19*m.b33*m.b38 + 128*m.b14*
m.b19*m.b34*m.b39 + 64*m.b14*m.b19*m.b35*m.b40 + 64*m.b14*m.b20*m.b21*m.b27 + 64*m.b14*m.b20*
m.b22*m.b28 + 64*m.b14*m.b20*m.b23*m.b29 + 704*m.b14*m.b20*m.b24*m.b30 + 640*m.b14*m.b20*m.b25*
m.b31 + 576*m.b14*m.b20*m.b26*m.b32 + 512*m.b14*m.b20*m.b27*m.b33 + 448*m.b14*m.b20*m.b28*m.b34
+ 384*m.b14*m.b20*m.b29*m.b35 + 320*m.b14*m.b20*m.b30*m.b36 + 256*m.b14*m.b20*m.b31*m.b37 + 192*
m.b14*m.b20*m.b32*m.b38 + 128*m.b14*m.b20*m.b33*m.b39 + 64*m.b14*m.b20*m.b34*m.b40 + 64*m.b14*
m.b21*m.b22*m.b29 + 704*m.b14*m.b21*m.b23*m.b30 + 640*m.b14*m.b21*m.b24*m.b31 + 576*m.b14*m.b21*
m.b25*m.b32 + 512*m.b14*m.b21*m.b26*m.b33 + 448*m.b14*m.b21*m.b27*m.b34 + 384*m.b14*m.b21*m.b28*
m.b35 + 320*m.b14*m.b21*m.b29*m.b36 + 256*m.b14*m.b21*m.b30*m.b37 + 192*m.b14*m.b21*m.b31*m.b38
+ 128*m.b14*m.b21*m.b32*m.b39 + 64*m.b14*m.b21*m.b33*m.b40 + 640*m.b14*m.b22*m.b23*m.b31 + 576*
m.b14*m.b22*m.b24*m.b32 + 512*m.b14*m.b22*m.b25*m.b33 + 448*m.b14*m.b22*m.b26*m.b34 + 384*m.b14*
m.b22*m.b27*m.b35 + 320*m.b14*m.b22*m.b28*m.b36 + 256*m.b14*m.b22*m.b29*m.b37 + 192*m.b14*m.b22*
m.b30*m.b38 + 128*m.b14*m.b22*m.b31*m.b39 + 64*m.b14*m.b22*m.b32*m.b40 + 512*m.b14*m.b23*m.b24*
m.b33 + 448*m.b14*m.b23*m.b25*m.b34 + 384*m.b14*m.b23*m.b26*m.b35 + 320*m.b14*m.b23*m.b27*m.b36
+ 256*m.b14*m.b23*m.b28*m.b37 + 192*m.b14*m.b23*m.b29*m.b38 + 128*m.b14*m.b23*m.b30*m.b39 + 64*
m.b14*m.b23*m.b31*m.b40 + 384*m.b14*m.b24*m.b25*m.b35 + 320*m.b14*m.b24*m.b26*m.b36 + 256*m.b14*
m.b24*m.b27*m.b37 + 192*m.b14*m.b24*m.b28*m.b38 + 128*m.b14*m.b24*m.b29*m.b39 + 64*m.b14*m.b24*
m.b30*m.b40 + 256*m.b14*m.b25*m.b26*m.b37 + 192*m.b14*m.b25*m.b27*m.b38 + 128*m.b14*m.b25*m.b28*
m.b39 + 64*m.b14*m.b25*m.b29*m.b40 + 128*m.b14*m.b26*m.b27*m.b39 + 64*m.b14*m.b26*m.b28*m.b40 +
64*m.b15*m.b16*m.b17*m.b18 + 64*m.b15*m.b16*m.b18*m.b19 + 64*m.b15*m.b16*m.b19*m.b20 + 64*m.b15*
m.b16*m.b20*m.b21 + 64*m.b15*m.b16*m.b21*m.b22 + 64*m.b15*m.b16*m.b22*m.b23 + 64*m.b15*m.b16*
m.b23*m.b24 + 64*m.b15*m.b16*m.b24*m.b25 + 64*m.b15*m.b16*m.b25*m.b26 + 64*m.b15*m.b16*m.b26*
m.b27 + 64*m.b15*m.b16*m.b27*m.b28 + 64*m.b15*m.b16*m.b28*m.b29 + 64*m.b15*m.b16*m.b29*m.b30 +
640*m.b15*m.b16*m.b30*m.b31 + 576*m.b15*m.b16*m.b31*m.b32 + 512*m.b15*m.b16*m.b32*m.b33 + 448*
m.b15*m.b16*m.b33*m.b34 + 384*m.b15*m.b16*m.b34*m.b35 + 320*m.b15*m.b16*m.b35*m.b36 + 256*m.b15*
m.b16*m.b36*m.b37 + 192*m.b15*m.b16*m.b37*m.b38 + 128*m.b15*m.b16*m.b38*m.b39 + 64*m.b15*m.b16*
m.b39*m.b40 + 64*m.b15*m.b17*m.b18*m.b20 + 64*m.b15*m.b17*m.b19*m.b21 + 64*m.b15*m.b17*m.b20*
m.b22 + 64*m.b15*m.b17*m.b21*m.b23 + 64*m.b15*m.b17*m.b22*m.b24 + 64*m.b15*m.b17*m.b23*m.b25 + 64
*m.b15*m.b17*m.b24*m.b26 + 64*m.b15*m.b17*m.b25*m.b27 + 64*m.b15*m.b17*m.b26*m.b28 + 64*m.b15*
m.b17*m.b27*m.b29 + 64*m.b15*m.b17*m.b28*m.b30 + 640*m.b15*m.b17*m.b29*m.b31 + 576*m.b15*m.b17*
m.b30*m.b32 + 512*m.b15*m.b17*m.b31*m.b33 + 448*m.b15*m.b17*m.b32*m.b34 + 384*m.b15*m.b17*m.b33*
m.b35 + 320*m.b15*m.b17*m.b34*m.b36 + 256*m.b15*m.b17*m.b35*m.b37 + 192*m.b15*m.b17*m.b36*m.b38
+ 128*m.b15*m.b17*m.b37*m.b39 + 64*m.b15*m.b17*m.b38*m.b40 + 64*m.b15*m.b18*m.b19*m.b22 + 64*
m.b15*m.b18*m.b20*m.b23 + 64*m.b15*m.b18*m.b21*m.b24 + 64*m.b15*m.b18*m.b22*m.b25 + 64*m.b15*
m.b18*m.b23*m.b26 + 64*m.b15*m.b18*m.b24*m.b27 + 64*m.b15*m.b18*m.b25*m.b28 + 64*m.b15*m.b18*
m.b26*m.b29 + 64*m.b15*m.b18*m.b27*m.b30 + 640*m.b15*m.b18*m.b28*m.b31 + 576*m.b15*m.b18*m.b29*
m.b32 + 512*m.b15*m.b18*m.b30*m.b33 + 448*m.b15*m.b18*m.b31*m.b34 + 384*m.b15*m.b18*m.b32*m.b35
+ 320*m.b15*m.b18*m.b33*m.b36 + 256*m.b15*m.b18*m.b34*m.b37 + 192*m.b15*m.b18*m.b35*m.b38 + 128*
m.b15*m.b18*m.b36*m.b39 + 64*m.b15*m.b18*m.b37*m.b40 + 64*m.b15*m.b19*m.b20*m.b24 + 64*m.b15*
m.b19*m.b21*m.b25 + 64*m.b15*m.b19*m.b22*m.b26 + 64*m.b15*m.b19*m.b23*m.b27 + 64*m.b15*m.b19*
m.b24*m.b28 + 64*m.b15*m.b19*m.b25*m.b29 + 64*m.b15*m.b19*m.b26*m.b30 + 640*m.b15*m.b19*m.b27*
m.b31 + 576*m.b15*m.b19*m.b28*m.b32 + 512*m.b15*m.b19*m.b29*m.b33 + 448*m.b15*m.b19*m.b30*m.b34
+ 384*m.b15*m.b19*m.b31*m.b35 + 320*m.b15*m.b19*m.b32*m.b36 + 256*m.b15*m.b19*m.b33*m.b37 + 192*
m.b15*m.b19*m.b34*m.b38 + 128*m.b15*m.b19*m.b35*m.b39 + 64*m.b15*m.b19*m.b36*m.b40 + 64*m.b15*
m.b20*m.b21*m.b26 + 64*m.b15*m.b20*m.b22*m.b27 + 64*m.b15*m.b20*m.b23*m.b28 + 64*m.b15*m.b20*
m.b24*m.b29 + 64*m.b15*m.b20*m.b25*m.b30 + 640*m.b15*m.b20*m.b26*m.b31 + 576*m.b15*m.b20*m.b27*
m.b32 + 512*m.b15*m.b20*m.b28*m.b33 + 448*m.b15*m.b20*m.b29*m.b34 + 384*m.b15*m.b20*m.b30*m.b35
+ 320*m.b15*m.b20*m.b31*m.b36 + 256*m.b15*m.b20*m.b32*m.b37 + 192*m.b15*m.b20*m.b33*m.b38 + 128*
m.b15*m.b20*m.b34*m.b39 + 64*m.b15*m.b20*m.b35*m.b40 + 64*m.b15*m.b21*m.b22*m.b28 + 64*m.b15*
m.b21*m.b23*m.b29 + 64*m.b15*m.b21*m.b24*m.b30 + 640*m.b15*m.b21*m.b25*m.b31 + 576*m.b15*m.b21*
m.b26*m.b32 + 512*m.b15*m.b21*m.b27*m.b33 + 448*m.b15*m.b21*m.b28*m.b34 + 384*m.b15*m.b21*m.b29*
m.b35 + 320*m.b15*m.b21*m.b30*m.b36 + 256*m.b15*m.b21*m.b31*m.b37 + 192*m.b15*m.b21*m.b32*m.b38
+ 128*m.b15*m.b21*m.b33*m.b39 + 64*m.b15*m.b21*m.b34*m.b40 + 64*m.b15*m.b22*m.b23*m.b30 + 640*
m.b15*m.b22*m.b24*m.b31 + 576*m.b15*m.b22*m.b25*m.b32 + 512*m.b15*m.b22*m.b26*m.b33 + 448*m.b15*
m.b22*m.b27*m.b34 + 384*m.b15*m.b22*m.b28*m.b35 + 320*m.b15*m.b22*m.b29*m.b36 + 256*m.b15*m.b22*
m.b30*m.b37 + 192*m.b15*m.b22*m.b31*m.b38 + 128*m.b15*m.b22*m.b32*m.b39 + 64*m.b15*m.b22*m.b33*
m.b40 + 576*m.b15*m.b23*m.b24*m.b32 + 512*m.b15*m.b23*m.b25*m.b33 + 448*m.b15*m.b23*m.b26*m.b34
+ 384*m.b15*m.b23*m.b27*m.b35 + 320*m.b15*m.b23*m.b28*m.b36 + 256*m.b15*m.b23*m.b29*m.b37 + 192*
m.b15*m.b23*m.b30*m.b38 + 128*m.b15*m.b23*m.b31*m.b39 + 64*m.b15*m.b23*m.b32*m.b40 + 448*m.b15*
m.b24*m.b25*m.b34 + 384*m.b15*m.b24*m.b26*m.b35 + 320*m.b15*m.b24*m.b27*m.b36 + 256*m.b15*m.b24*
m.b28*m.b37 + 192*m.b15*m.b24*m.b29*m.b38 + 128*m.b15*m.b24*m.b30*m.b39 + 64*m.b15*m.b24*m.b31*
m.b40 + 320*m.b15*m.b25*m.b26*m.b36 + 256*m.b15*m.b25*m.b27*m.b37 + 192*m.b15*m.b25*m.b28*m.b38
+ 128*m.b15*m.b25*m.b29*m.b39 + 64*m.b15*m.b25*m.b30*m.b40 + 192*m.b15*m.b26*m.b27*m.b38 + 128*
m.b15*m.b26*m.b28*m.b39 + 64*m.b15*m.b26*m.b29*m.b40 + 64*m.b15*m.b27*m.b28*m.b40 + 64*m.b16*
m.b17*m.b18*m.b19 + 64*m.b16*m.b17*m.b19*m.b20 + 64*m.b16*m.b17*m.b20*m.b21 + 64*m.b16*m.b17*
m.b21*m.b22 + 64*m.b16*m.b17*m.b22*m.b23 + 64*m.b16*m.b17*m.b23*m.b24 + 64*m.b16*m.b17*m.b24*
m.b25 + 64*m.b16*m.b17*m.b25*m.b26 + 64*m.b16*m.b17*m.b26*m.b27 + 64*m.b16*m.b17*m.b27*m.b28 + 64
*m.b16*m.b17*m.b28*m.b29 + 64*m.b16*m.b17*m.b29*m.b30 + 64*m.b16*m.b17*m.b30*m.b31 + 576*m.b16*
m.b17*m.b31*m.b32 + 512*m.b16*m.b17*m.b32*m.b33 + 448*m.b16*m.b17*m.b33*m.b34 + 384*m.b16*m.b17*
m.b34*m.b35 + 320*m.b16*m.b17*m.b35*m.b36 + 256*m.b16*m.b17*m.b36*m.b37 + 192*m.b16*m.b17*m.b37*
m.b38 + 128*m.b16*m.b17*m.b38*m.b39 + 64*m.b16*m.b17*m.b39*m.b40 + 64*m.b16*m.b18*m.b19*m.b21 +
64*m.b16*m.b18*m.b20*m.b22 + 64*m.b16*m.b18*m.b21*m.b23 + 64*m.b16*m.b18*m.b22*m.b24 + 64*m.b16*
m.b18*m.b23*m.b25 + 64*m.b16*m.b18*m.b24*m.b26 + 64*m.b16*m.b18*m.b25*m.b27 + 64*m.b16*m.b18*
m.b26*m.b28 + 64*m.b16*m.b18*m.b27*m.b29 + 64*m.b16*m.b18*m.b28*m.b30 + 64*m.b16*m.b18*m.b29*
m.b31 + 576*m.b16*m.b18*m.b30*m.b32 + 512*m.b16*m.b18*m.b31*m.b33 + 448*m.b16*m.b18*m.b32*m.b34
+ 384*m.b16*m.b18*m.b33*m.b35 + 320*m.b16*m.b18*m.b34*m.b36 + 256*m.b16*m.b18*m.b35*m.b37 + 192*
m.b16*m.b18*m.b36*m.b38 + 128*m.b16*m.b18*m.b37*m.b39 + 64*m.b16*m.b18*m.b38*m.b40 + 64*m.b16*
m.b19*m.b20*m.b23 + 64*m.b16*m.b19*m.b21*m.b24 + 64*m.b16*m.b19*m.b22*m.b25 + 64*m.b16*m.b19*
m.b23*m.b26 + 64*m.b16*m.b19*m.b24*m.b27 + 64*m.b16*m.b19*m.b25*m.b28 + 64*m.b16*m.b19*m.b26*
m.b29 + 64*m.b16*m.b19*m.b27*m.b30 + 64*m.b16*m.b19*m.b28*m.b31 + 576*m.b16*m.b19*m.b29*m.b32 +
512*m.b16*m.b19*m.b30*m.b33 + 448*m.b16*m.b19*m.b31*m.b34 + 384*m.b16*m.b19*m.b32*m.b35 + 320*
m.b16*m.b19*m.b33*m.b36 + 256*m.b16*m.b19*m.b34*m.b37 + 192*m.b16*m.b19*m.b35*m.b38 + 128*m.b16*
m.b19*m.b36*m.b39 + 64*m.b16*m.b19*m.b37*m.b40 + 64*m.b16*m.b20*m.b21*m.b25 + 64*m.b16*m.b20*
m.b22*m.b26 + 64*m.b16*m.b20*m.b23*m.b27 + 64*m.b16*m.b20*m.b24*m.b28 + 64*m.b16*m.b20*m.b25*
m.b29 + 64*m.b16*m.b20*m.b26*m.b30 + 64*m.b16*m.b20*m.b27*m.b31 + 576*m.b16*m.b20*m.b28*m.b32 +
512*m.b16*m.b20*m.b29*m.b33 + 448*m.b16*m.b20*m.b30*m.b34 + 384*m.b16*m.b20*m.b31*m.b35 + 320*
m.b16*m.b20*m.b32*m.b36 + 256*m.b16*m.b20*m.b33*m.b37 + 192*m.b16*m.b20*m.b34*m.b38 + 128*m.b16*
m.b20*m.b35*m.b39 + 64*m.b16*m.b20*m.b36*m.b40 + 64*m.b16*m.b21*m.b22*m.b27 + 64*m.b16*m.b21*
m.b23*m.b28 + 64*m.b16*m.b21*m.b24*m.b29 + 64*m.b16*m.b21*m.b25*m.b30 + 64*m.b16*m.b21*m.b26*
m.b31 + 576*m.b16*m.b21*m.b27*m.b32 + 512*m.b16*m.b21*m.b28*m.b33 + 448*m.b16*m.b21*m.b29*m.b34
+ 384*m.b16*m.b21*m.b30*m.b35 + 320*m.b16*m.b21*m.b31*m.b36 + 256*m.b16*m.b21*m.b32*m.b37 + 192*
m.b16*m.b21*m.b33*m.b38 + 128*m.b16*m.b21*m.b34*m.b39 + 64*m.b16*m.b21*m.b35*m.b40 + 64*m.b16*
m.b22*m.b23*m.b29 + 64*m.b16*m.b22*m.b24*m.b30 + 64*m.b16*m.b22*m.b25*m.b31 + 576*m.b16*m.b22*
m.b26*m.b32 + 512*m.b16*m.b22*m.b27*m.b33 + 448*m.b16*m.b22*m.b28*m.b34 + 384*m.b16*m.b22*m.b29*
m.b35 + 320*m.b16*m.b22*m.b30*m.b36 + 256*m.b16*m.b22*m.b31*m.b37 + 192*m.b16*m.b22*m.b32*m.b38
+ 128*m.b16*m.b22*m.b33*m.b39 + 64*m.b16*m.b22*m.b34*m.b40 + 64*m.b16*m.b23*m.b24*m.b31 + 576*
m.b16*m.b23*m.b25*m.b32 + 512*m.b16*m.b23*m.b26*m.b33 + 448*m.b16*m.b23*m.b27*m.b34 + 384*m.b16*
m.b23*m.b28*m.b35 + 320*m.b16*m.b23*m.b29*m.b36 + 256*m.b16*m.b23*m.b30*m.b37 + 192*m.b16*m.b23*
m.b31*m.b38 + 128*m.b16*m.b23*m.b32*m.b39 + 64*m.b16*m.b23*m.b33*m.b40 + 512*m.b16*m.b24*m.b25*
m.b33 + 448*m.b16*m.b24*m.b26*m.b34 + 384*m.b16*m.b24*m.b27*m.b35 + 320*m.b16*m.b24*m.b28*m.b36
+ 256*m.b16*m.b24*m.b29*m.b37 + 192*m.b16*m.b24*m.b30*m.b38 + 128*m.b16*m.b24*m.b31*m.b39 + 64*
m.b16*m.b24*m.b32*m.b40 + 384*m.b16*m.b25*m.b26*m.b35 + 320*m.b16*m.b25*m.b27*m.b36 + 256*m.b16*
m.b25*m.b28*m.b37 + 192*m.b16*m.b25*m.b29*m.b38 + 128*m.b16*m.b25*m.b30*m.b39 + 64*m.b16*m.b25*
m.b31*m.b40 + 256*m.b16*m.b26*m.b27*m.b37 + 192*m.b16*m.b26*m.b28*m.b38 + 128*m.b16*m.b26*m.b29*
m.b39 + 64*m.b16*m.b26*m.b30*m.b40 + 128*m.b16*m.b27*m.b28*m.b39 + 64*m.b16*m.b27*m.b29*m.b40 +
64*m.b17*m.b18*m.b19*m.b20 + 64*m.b17*m.b18*m.b20*m.b21 + 64*m.b17*m.b18*m.b21*m.b22 + 64*m.b17*
m.b18*m.b22*m.b23 + 64*m.b17*m.b18*m.b23*m.b24 + 64*m.b17*m.b18*m.b24*m.b25 + 64*m.b17*m.b18*
m.b25*m.b26 + 64*m.b17*m.b18*m.b26*m.b27 + 64*m.b17*m.b18*m.b27*m.b28 + 64*m.b17*m.b18*m.b28*
m.b29 + 64*m.b17*m.b18*m.b29*m.b30 + 64*m.b17*m.b18*m.b30*m.b31 + 64*m.b17*m.b18*m.b31*m.b32 +
512*m.b17*m.b18*m.b32*m.b33 + 448*m.b17*m.b18*m.b33*m.b34 + 384*m.b17*m.b18*m.b34*m.b35 + 320*
m.b17*m.b18*m.b35*m.b36 + 256*m.b17*m.b18*m.b36*m.b37 + 192*m.b17*m.b18*m.b37*m.b38 + 128*m.b17*
m.b18*m.b38*m.b39 + 64*m.b17*m.b18*m.b39*m.b40 + 64*m.b17*m.b19*m.b20*m.b22 + 64*m.b17*m.b19*
m.b21*m.b23 + 64*m.b17*m.b19*m.b22*m.b24 + 64*m.b17*m.b19*m.b23*m.b25 + 64*m.b17*m.b19*m.b24*
m.b26 + 64*m.b17*m.b19*m.b25*m.b27 + 64*m.b17*m.b19*m.b26*m.b28 + 64*m.b17*m.b19*m.b27*m.b29 + 64
*m.b17*m.b19*m.b28*m.b30 + 64*m.b17*m.b19*m.b29*m.b31 + 64*m.b17*m.b19*m.b30*m.b32 + 512*m.b17*
m.b19*m.b31*m.b33 + 448*m.b17*m.b19*m.b32*m.b34 + 384*m.b17*m.b19*m.b33*m.b35 + 320*m.b17*m.b19*
m.b34*m.b36 + 256*m.b17*m.b19*m.b35*m.b37 + 192*m.b17*m.b19*m.b36*m.b38 + 128*m.b17*m.b19*m.b37*
m.b39 + 64*m.b17*m.b19*m.b38*m.b40 + 64*m.b17*m.b20*m.b21*m.b24 + 64*m.b17*m.b20*m.b22*m.b25 + 64
*m.b17*m.b20*m.b23*m.b26 + 64*m.b17*m.b20*m.b24*m.b27 + 64*m.b17*m.b20*m.b25*m.b28 + 64*m.b17*
m.b20*m.b26*m.b29 + 64*m.b17*m.b20*m.b27*m.b30 + 64*m.b17*m.b20*m.b28*m.b31 + 64*m.b17*m.b20*
m.b29*m.b32 + 512*m.b17*m.b20*m.b30*m.b33 + 448*m.b17*m.b20*m.b31*m.b34 + 384*m.b17*m.b20*m.b32*
m.b35 + 320*m.b17*m.b20*m.b33*m.b36 + 256*m.b17*m.b20*m.b34*m.b37 + 192*m.b17*m.b20*m.b35*m.b38
+ 128*m.b17*m.b20*m.b36*m.b39 + 64*m.b17*m.b20*m.b37*m.b40 + 64*m.b17*m.b21*m.b22*m.b26 + 64*
m.b17*m.b21*m.b23*m.b27 + 64*m.b17*m.b21*m.b24*m.b28 + 64*m.b17*m.b21*m.b25*m.b29 + 64*m.b17*
m.b21*m.b26*m.b30 + 64*m.b17*m.b21*m.b27*m.b31 + 64*m.b17*m.b21*m.b28*m.b32 + 512*m.b17*m.b21*
m.b29*m.b33 + 448*m.b17*m.b21*m.b30*m.b34 + 384*m.b17*m.b21*m.b31*m.b35 + 320*m.b17*m.b21*m.b32*
m.b36 + 256*m.b17*m.b21*m.b33*m.b37 + 192*m.b17*m.b21*m.b34*m.b38 + 128*m.b17*m.b21*m.b35*m.b39
+ 64*m.b17*m.b21*m.b36*m.b40 + 64*m.b17*m.b22*m.b23*m.b28 + 64*m.b17*m.b22*m.b24*m.b29 + 64*
m.b17*m.b22*m.b25*m.b30 + 64*m.b17*m.b22*m.b26*m.b31 + 64*m.b17*m.b22*m.b27*m.b32 + 512*m.b17*
m.b22*m.b28*m.b33 + 448*m.b17*m.b22*m.b29*m.b34 + 384*m.b17*m.b22*m.b30*m.b35 + 320*m.b17*m.b22*
m.b31*m.b36 + 256*m.b17*m.b22*m.b32*m.b37 + 192*m.b17*m.b22*m.b33*m.b38 + 128*m.b17*m.b22*m.b34*
m.b39 + 64*m.b17*m.b22*m.b35*m.b40 + 64*m.b17*m.b23*m.b24*m.b30 + 64*m.b17*m.b23*m.b25*m.b31 + 64
*m.b17*m.b23*m.b26*m.b32 + 512*m.b17*m.b23*m.b27*m.b33 + 448*m.b17*m.b23*m.b28*m.b34 + 384*m.b17*
m.b23*m.b29*m.b35 + 320*m.b17*m.b23*m.b30*m.b36 + 256*m.b17*m.b23*m.b31*m.b37 + 192*m.b17*m.b23*
m.b32*m.b38 + 128*m.b17*m.b23*m.b33*m.b39 + 64*m.b17*m.b23*m.b34*m.b40 + 64*m.b17*m.b24*m.b25*
m.b32 + 512*m.b17*m.b24*m.b26*m.b33 + 448*m.b17*m.b24*m.b27*m.b34 + 384*m.b17*m.b24*m.b28*m.b35
+ 320*m.b17*m.b24*m.b29*m.b36 + 256*m.b17*m.b24*m.b30*m.b37 + 192*m.b17*m.b24*m.b31*m.b38 + 128*
m.b17*m.b24*m.b32*m.b39 + 64*m.b17*m.b24*m.b33*m.b40 + 448*m.b17*m.b25*m.b26*m.b34 + 384*m.b17*
m.b25*m.b27*m.b35 + 320*m.b17*m.b25*m.b28*m.b36 + 256*m.b17*m.b25*m.b29*m.b37 + 192*m.b17*m.b25*
m.b30*m.b38 + 128*m.b17*m.b25*m.b31*m.b39 + 64*m.b17*m.b25*m.b32*m.b40 + 320*m.b17*m.b26*m.b27*
m.b36 + 256*m.b17*m.b26*m.b28*m.b37 + 192*m.b17*m.b26*m.b29*m.b38 + 128*m.b17*m.b26*m.b30*m.b39
+ 64*m.b17*m.b26*m.b31*m.b40 + 192*m.b17*m.b27*m.b28*m.b38 + 128*m.b17*m.b27*m.b29*m.b39 + 64*
m.b17*m.b27*m.b30*m.b40 + 64*m.b17*m.b28*m.b29*m.b40 + 64*m.b18*m.b19*m.b20*m.b21 + 64*m.b18*
m.b19*m.b21*m.b22 + 64*m.b18*m.b19*m.b22*m.b23 + 64*m.b18*m.b19*m.b23*m.b24 + 64*m.b18*m.b19*
m.b24*m.b25 + 64*m.b18*m.b19*m.b25*m.b26 + 64*m.b18*m.b19*m.b26*m.b27 + 64*m.b18*m.b19*m.b27*
m.b28 + 64*m.b18*m.b19*m.b28*m.b29 + 64*m.b18*m.b19*m.b29*m.b30 + 64*m.b18*m.b19*m.b30*m.b31 + 64
*m.b18*m.b19*m.b31*m.b32 + 64*m.b18*m.b19*m.b32*m.b33 + 448*m.b18*m.b19*m.b33*m.b34 + 384*m.b18*
m.b19*m.b34*m.b35 + 320*m.b18*m.b19*m.b35*m.b36 + 256*m.b18*m.b19*m.b36*m.b37 + 192*m.b18*m.b19*
m.b37*m.b38 + 128*m.b18*m.b19*m.b38*m.b39 + 64*m.b18*m.b19*m.b39*m.b40 + 64*m.b18*m.b20*m.b21*
m.b23 + 64*m.b18*m.b20*m.b22*m.b24 + 64*m.b18*m.b20*m.b23*m.b25 + 64*m.b18*m.b20*m.b24*m.b26 + 64
*m.b18*m.b20*m.b25*m.b27 + 64*m.b18*m.b20*m.b26*m.b28 + 64*m.b18*m.b20*m.b27*m.b29 + 64*m.b18*
m.b20*m.b28*m.b30 + 64*m.b18*m.b20*m.b29*m.b31 + 64*m.b18*m.b20*m.b30*m.b32 + 64*m.b18*m.b20*
m.b31*m.b33 + 448*m.b18*m.b20*m.b32*m.b34 + 384*m.b18*m.b20*m.b33*m.b35 + 320*m.b18*m.b20*m.b34*
m.b36 + 256*m.b18*m.b20*m.b35*m.b37 + 192*m.b18*m.b20*m.b36*m.b38 + 128*m.b18*m.b20*m.b37*m.b39
+ 64*m.b18*m.b20*m.b38*m.b40 + 64*m.b18*m.b21*m.b22*m.b25 + 64*m.b18*m.b21*m.b23*m.b26 + 64*
m.b18*m.b21*m.b24*m.b27 + 64*m.b18*m.b21*m.b25*m.b28 + 64*m.b18*m.b21*m.b26*m.b29 + 64*m.b18*
m.b21*m.b27*m.b30 + 64*m.b18*m.b21*m.b28*m.b31 + 64*m.b18*m.b21*m.b29*m.b32 + 64*m.b18*m.b21*
m.b30*m.b33 + 448*m.b18*m.b21*m.b31*m.b34 + 384*m.b18*m.b21*m.b32*m.b35 + 320*m.b18*m.b21*m.b33*
m.b36 + 256*m.b18*m.b21*m.b34*m.b37 + 192*m.b18*m.b21*m.b35*m.b38 + 128*m.b18*m.b21*m.b36*m.b39
+ 64*m.b18*m.b21*m.b37*m.b40 + 64*m.b18*m.b22*m.b23*m.b27 + 64*m.b18*m.b22*m.b24*m.b28 + 64*
m.b18*m.b22*m.b25*m.b29 + 64*m.b18*m.b22*m.b26*m.b30 + 64*m.b18*m.b22*m.b27*m.b31 + 64*m.b18*
m.b22*m.b28*m.b32 + 64*m.b18*m.b22*m.b29*m.b33 + 448*m.b18*m.b22*m.b30*m.b34 + 384*m.b18*m.b22*
m.b31*m.b35 + 320*m.b18*m.b22*m.b32*m.b36 + 256*m.b18*m.b22*m.b33*m.b37 + 192*m.b18*m.b22*m.b34*
m.b38 + 128*m.b18*m.b22*m.b35*m.b39 + 64*m.b18*m.b22*m.b36*m.b40 + 64*m.b18*m.b23*m.b24*m.b29 +
64*m.b18*m.b23*m.b25*m.b30 + 64*m.b18*m.b23*m.b26*m.b31 + 64*m.b18*m.b23*m.b27*m.b32 + 64*m.b18*
m.b23*m.b28*m.b33 + 448*m.b18*m.b23*m.b29*m.b34 + 384*m.b18*m.b23*m.b30*m.b35 + 320*m.b18*m.b23*
m.b31*m.b36 + 256*m.b18*m.b23*m.b32*m.b37 + 192*m.b18*m.b23*m.b33*m.b38 + 128*m.b18*m.b23*m.b34*
m.b39 + 64*m.b18*m.b23*m.b35*m.b40 + 64*m.b18*m.b24*m.b25*m.b31 + 64*m.b18*m.b24*m.b26*m.b32 + 64
*m.b18*m.b24*m.b27*m.b33 + 448*m.b18*m.b24*m.b28*m.b34 + 384*m.b18*m.b24*m.b29*m.b35 + 320*m.b18*
m.b24*m.b30*m.b36 + 256*m.b18*m.b24*m.b31*m.b37 + 192*m.b18*m.b24*m.b32*m.b38 + 128*m.b18*m.b24*
m.b33*m.b39 + 64*m.b18*m.b24*m.b34*m.b40 + 64*m.b18*m.b25*m.b26*m.b33 + 448*m.b18*m.b25*m.b27*
m.b34 + 384*m.b18*m.b25*m.b28*m.b35 + 320*m.b18*m.b25*m.b29*m.b36 + 256*m.b18*m.b25*m.b30*m.b37
+ 192*m.b18*m.b25*m.b31*m.b38 + 128*m.b18*m.b25*m.b32*m.b39 + 64*m.b18*m.b25*m.b33*m.b40 + 384*
m.b18*m.b26*m.b27*m.b35 + 320*m.b18*m.b26*m.b28*m.b36 + 256*m.b18*m.b26*m.b29*m.b37 + 192*m.b18*
m.b26*m.b30*m.b38 + 128*m.b18*m.b26*m.b31*m.b39 + 64*m.b18*m.b26*m.b32*m.b40 + 256*m.b18*m.b27*
m.b28*m.b37 + 192*m.b18*m.b27*m.b29*m.b38 + 128*m.b18*m.b27*m.b30*m.b39 + 64*m.b18*m.b27*m.b31*
m.b40 + 128*m.b18*m.b28*m.b29*m.b39 + 64*m.b18*m.b28*m.b30*m.b40 + 64*m.b19*m.b20*m.b21*m.b22 +
64*m.b19*m.b20*m.b22*m.b23 + 64*m.b19*m.b20*m.b23*m.b24 + 64*m.b19*m.b20*m.b24*m.b25 + 64*m.b19*
m.b20*m.b25*m.b26 + 64*m.b19*m.b20*m.b26*m.b27 + 64*m.b19*m.b20*m.b27*m.b28 + 64*m.b19*m.b20*
m.b28*m.b29 + 64*m.b19*m.b20*m.b29*m.b30 + 64*m.b19*m.b20*m.b30*m.b31 + 64*m.b19*m.b20*m.b31*
m.b32 + 64*m.b19*m.b20*m.b32*m.b33 + 64*m.b19*m.b20*m.b33*m.b34 + 384*m.b19*m.b20*m.b34*m.b35 +
320*m.b19*m.b20*m.b35*m.b36 + 256*m.b19*m.b20*m.b36*m.b37 + 192*m.b19*m.b20*m.b37*m.b38 + 128*
m.b19*m.b20*m.b38*m.b39 + 64*m.b19*m.b20*m.b39*m.b40 + 64*m.b19*m.b21*m.b22*m.b24 + 64*m.b19*
m.b21*m.b23*m.b25 + 64*m.b19*m.b21*m.b24*m.b26 + 64*m.b19*m.b21*m.b25*m.b27 + 64*m.b19*m.b21*
m.b26*m.b28 + 64*m.b19*m.b21*m.b27*m.b29 + 64*m.b19*m.b21*m.b28*m.b30 + 64*m.b19*m.b21*m.b29*
m.b31 + 64*m.b19*m.b21*m.b30*m.b32 + 64*m.b19*m.b21*m.b31*m.b33 + 64*m.b19*m.b21*m.b32*m.b34 +
384*m.b19*m.b21*m.b33*m.b35 + 320*m.b19*m.b21*m.b34*m.b36 + 256*m.b19*m.b21*m.b35*m.b37 + 192*
m.b19*m.b21*m.b36*m.b38 + 128*m.b19*m.b21*m.b37*m.b39 + 64*m.b19*m.b21*m.b38*m.b40 + 64*m.b19*
m.b22*m.b23*m.b26 + 64*m.b19*m.b22*m.b24*m.b27 + 64*m.b19*m.b22*m.b25*m.b28 + 64*m.b19*m.b22*
m.b26*m.b29 + 64*m.b19*m.b22*m.b27*m.b30 + 64*m.b19*m.b22*m.b28*m.b31 + 64*m.b19*m.b22*m.b29*
m.b32 + 64*m.b19*m.b22*m.b30*m.b33 + 64*m.b19*m.b22*m.b31*m.b34 + 384*m.b19*m.b22*m.b32*m.b35 +
320*m.b19*m.b22*m.b33*m.b36 + 256*m.b19*m.b22*m.b34*m.b37 + 192*m.b19*m.b22*m.b35*m.b38 + 128*
m.b19*m.b22*m.b36*m.b39 + 64*m.b19*m.b22*m.b37*m.b40 + 64*m.b19*m.b23*m.b24*m.b28 + 64*m.b19*
m.b23*m.b25*m.b29 + 64*m.b19*m.b23*m.b26*m.b30 + 64*m.b19*m.b23*m.b27*m.b31 + 64*m.b19*m.b23*
m.b28*m.b32 + 64*m.b19*m.b23*m.b29*m.b33 + 64*m.b19*m.b23*m.b30*m.b34 + 384*m.b19*m.b23*m.b31*
m.b35 + 320*m.b19*m.b23*m.b32*m.b36 + 256*m.b19*m.b23*m.b33*m.b37 + 192*m.b19*m.b23*m.b34*m.b38
+ 128*m.b19*m.b23*m.b35*m.b39 + 64*m.b19*m.b23*m.b36*m.b40 + 64*m.b19*m.b24*m.b25*m.b30 + 64*
m.b19*m.b24*m.b26*m.b31 + 64*m.b19*m.b24*m.b27*m.b32 + 64*m.b19*m.b24*m.b28*m.b33 + 64*m.b19*
m.b24*m.b29*m.b34 + 384*m.b19*m.b24*m.b30*m.b35 + 320*m.b19*m.b24*m.b31*m.b36 + 256*m.b19*m.b24*
m.b32*m.b37 + 192*m.b19*m.b24*m.b33*m.b38 + 128*m.b19*m.b24*m.b34*m.b39 + 64*m.b19*m.b24*m.b35*
m.b40 + 64*m.b19*m.b25*m.b26*m.b32 + 64*m.b19*m.b25*m.b27*m.b33 + 64*m.b19*m.b25*m.b28*m.b34 +
384*m.b19*m.b25*m.b29*m.b35 + 320*m.b19*m.b25*m.b30*m.b36 + 256*m.b19*m.b25*m.b31*m.b37 + 192*
m.b19*m.b25*m.b32*m.b38 + 128*m.b19*m.b25*m.b33*m.b39 + 64*m.b19*m.b25*m.b34*m.b40 + 64*m.b19*
m.b26*m.b27*m.b34 + 384*m.b19*m.b26*m.b28*m.b35 + 320*m.b19*m.b26*m.b29*m.b36 + 256*m.b19*m.b26*
m.b30*m.b37 + 192*m.b19*m.b26*m.b31*m.b38 + 128*m.b19*m.b26*m.b32*m.b39 + 64*m.b19*m.b26*m.b33*
m.b40 + 320*m.b19*m.b27*m.b28*m.b36 + 256*m.b19*m.b27*m.b29*m.b37 + 192*m.b19*m.b27*m.b30*m.b38
+ 128*m.b19*m.b27*m.b31*m.b39 + 64*m.b19*m.b27*m.b32*m.b40 + 192*m.b19*m.b28*m.b29*m.b38 + 128*
m.b19*m.b28*m.b30*m.b39 + 64*m.b19*m.b28*m.b31*m.b40 + 64*m.b19*m.b29*m.b30*m.b40 + 64*m.b20*
m.b21*m.b22*m.b23 + 64*m.b20*m.b21*m.b23*m.b24 + 64*m.b20*m.b21*m.b24*m.b25 + 64*m.b20*m.b21*
m.b25*m.b26 + 64*m.b20*m.b21*m.b26*m.b27 + 64*m.b20*m.b21*m.b27*m.b28 + 64*m.b20*m.b21*m.b28*
m.b29 + 64*m.b20*m.b21*m.b29*m.b30 + 64*m.b20*m.b21*m.b30*m.b31 + 64*m.b20*m.b21*m.b31*m.b32 + 64
*m.b20*m.b21*m.b32*m.b33 + 64*m.b20*m.b21*m.b33*m.b34 + 64*m.b20*m.b21*m.b34*m.b35 + 320*m.b20*
m.b21*m.b35*m.b36 + 256*m.b20*m.b21*m.b36*m.b37 + 192*m.b20*m.b21*m.b37*m.b38 + 128*m.b20*m.b21*
m.b38*m.b39 + 64*m.b20*m.b21*m.b39*m.b40 + 64*m.b20*m.b22*m.b23*m.b25 + 64*m.b20*m.b22*m.b24*
m.b26 + 64*m.b20*m.b22*m.b25*m.b27 + 64*m.b20*m.b22*m.b26*m.b28 + 64*m.b20*m.b22*m.b27*m.b29 + 64
*m.b20*m.b22*m.b28*m.b30 + 64*m.b20*m.b22*m.b29*m.b31 + 64*m.b20*m.b22*m.b30*m.b32 + 64*m.b20*
m.b22*m.b31*m.b33 + 64*m.b20*m.b22*m.b32*m.b34 + 64*m.b20*m.b22*m.b33*m.b35 + 320*m.b20*m.b22*
m.b34*m.b36 + 256*m.b20*m.b22*m.b35*m.b37 + 192*m.b20*m.b22*m.b36*m.b38 + 128*m.b20*m.b22*m.b37*
m.b39 + 64*m.b20*m.b22*m.b38*m.b40 + 64*m.b20*m.b23*m.b24*m.b27 + 64*m.b20*m.b23*m.b25*m.b28 + 64
*m.b20*m.b23*m.b26*m.b29 + 64*m.b20*m.b23*m.b27*m.b30 + 64*m.b20*m.b23*m.b28*m.b31 + 64*m.b20*
m.b23*m.b29*m.b32 + 64*m.b20*m.b23*m.b30*m.b33 + 64*m.b20*m.b23*m.b31*m.b34 + 64*m.b20*m.b23*
m.b32*m.b35 + 320*m.b20*m.b23*m.b33*m.b36 + 256*m.b20*m.b23*m.b34*m.b37 + 192*m.b20*m.b23*m.b35*
m.b38 + 128*m.b20*m.b23*m.b36*m.b39 + 64*m.b20*m.b23*m.b37*m.b40 + 64*m.b20*m.b24*m.b25*m.b29 +
64*m.b20*m.b24*m.b26*m.b30 + 64*m.b20*m.b24*m.b27*m.b31 + 64*m.b20*m.b24*m.b28*m.b32 + 64*m.b20*
m.b24*m.b29*m.b33 + 64*m.b20*m.b24*m.b30*m.b34 + 64*m.b20*m.b24*m.b31*m.b35 + 320*m.b20*m.b24*
m.b32*m.b36 + 256*m.b20*m.b24*m.b33*m.b37 + 192*m.b20*m.b24*m.b34*m.b38 + 128*m.b20*m.b24*m.b35*
m.b39 + 64*m.b20*m.b24*m.b36*m.b40 + 64*m.b20*m.b25*m.b26*m.b31 + 64*m.b20*m.b25*m.b27*m.b32 + 64
*m.b20*m.b25*m.b28*m.b33 + 64*m.b20*m.b25*m.b29*m.b34 + 64*m.b20*m.b25*m.b30*m.b35 + 320*m.b20*
m.b25*m.b31*m.b36 + 256*m.b20*m.b25*m.b32*m.b37 + 192*m.b20*m.b25*m.b33*m.b38 + 128*m.b20*m.b25*
m.b34*m.b39 + 64*m.b20*m.b25*m.b35*m.b40 + 64*m.b20*m.b26*m.b27*m.b33 + 64*m.b20*m.b26*m.b28*
m.b34 + 64*m.b20*m.b26*m.b29*m.b35 + 320*m.b20*m.b26*m.b30*m.b36 + 256*m.b20*m.b26*m.b31*m.b37 +
192*m.b20*m.b26*m.b32*m.b38 + 128*m.b20*m.b26*m.b33*m.b39 + 64*m.b20*m.b26*m.b34*m.b40 + 64*m.b20
*m.b27*m.b28*m.b35 + 320*m.b20*m.b27*m.b29*m.b36 + 256*m.b20*m.b27*m.b30*m.b37 + 192*m.b20*m.b27*
m.b31*m.b38 + 128*m.b20*m.b27*m.b32*m.b39 + 64*m.b20*m.b27*m.b33*m.b40 + 256*m.b20*m.b28*m.b29*
m.b37 + 192*m.b20*m.b28*m.b30*m.b38 + 128*m.b20*m.b28*m.b31*m.b39 + 64*m.b20*m.b28*m.b32*m.b40 +
128*m.b20*m.b29*m.b30*m.b39 + 64*m.b20*m.b29*m.b31*m.b40 + 64*m.b21*m.b22*m.b23*m.b24 + 64*m.b21*
m.b22*m.b24*m.b25 + 64*m.b21*m.b22*m.b25*m.b26 + 64*m.b21*m.b22*m.b26*m.b27 + 64*m.b21*m.b22*
m.b27*m.b28 + 64*m.b21*m.b22*m.b28*m.b29 + 64*m.b21*m.b22*m.b29*m.b30 + 64*m.b21*m.b22*m.b30*
m.b31 + 64*m.b21*m.b22*m.b31*m.b32 + 64*m.b21*m.b22*m.b32*m.b33 + 64*m.b21*m.b22*m.b33*m.b34 + 64
*m.b21*m.b22*m.b34*m.b35 + 64*m.b21*m.b22*m.b35*m.b36 + 256*m.b21*m.b22*m.b36*m.b37 + 192*m.b21*
m.b22*m.b37*m.b38 + 128*m.b21*m.b22*m.b38*m.b39 + 64*m.b21*m.b22*m.b39*m.b40 + 64*m.b21*m.b23*
m.b24*m.b26 + 64*m.b21*m.b23*m.b25*m.b27 + 64*m.b21*m.b23*m.b26*m.b28 + 64*m.b21*m.b23*m.b27*
m.b29 + 64*m.b21*m.b23*m.b28*m.b30 + 64*m.b21*m.b23*m.b29*m.b31 + 64*m.b21*m.b23*m.b30*m.b32 + 64
*m.b21*m.b23*m.b31*m.b33 + 64*m.b21*m.b23*m.b32*m.b34 + 64*m.b21*m.b23*m.b33*m.b35 + 64*m.b21*
m.b23*m.b34*m.b36 + 256*m.b21*m.b23*m.b35*m.b37 + 192*m.b21*m.b23*m.b36*m.b38 + 128*m.b21*m.b23*
m.b37*m.b39 + 64*m.b21*m.b23*m.b38*m.b40 + 64*m.b21*m.b24*m.b25*m.b28 + 64*m.b21*m.b24*m.b26*
m.b29 + 64*m.b21*m.b24*m.b27*m.b30 + 64*m.b21*m.b24*m.b28*m.b31 + 64*m.b21*m.b24*m.b29*m.b32 + 64
*m.b21*m.b24*m.b30*m.b33 + 64*m.b21*m.b24*m.b31*m.b34 + 64*m.b21*m.b24*m.b32*m.b35 + 64*m.b21*
m.b24*m.b33*m.b36 + 256*m.b21*m.b24*m.b34*m.b37 + 192*m.b21*m.b24*m.b35*m.b38 + 128*m.b21*m.b24*
m.b36*m.b39 + 64*m.b21*m.b24*m.b37*m.b40 + 64*m.b21*m.b25*m.b26*m.b30 + 64*m.b21*m.b25*m.b27*
m.b31 + 64*m.b21*m.b25*m.b28*m.b32 + 64*m.b21*m.b25*m.b29*m.b33 + 64*m.b21*m.b25*m.b30*m.b34 + 64
*m.b21*m.b25*m.b31*m.b35 + 64*m.b21*m.b25*m.b32*m.b36 + 256*m.b21*m.b25*m.b33*m.b37 + 192*m.b21*
m.b25*m.b34*m.b38 + 128*m.b21*m.b25*m.b35*m.b39 + 64*m.b21*m.b25*m.b36*m.b40 + 64*m.b21*m.b26*
m.b27*m.b32 + 64*m.b21*m.b26*m.b28*m.b33 + 64*m.b21*m.b26*m.b29*m.b34 + 64*m.b21*m.b26*m.b30*
m.b35 + 64*m.b21*m.b26*m.b31*m.b36 + 256*m.b21*m.b26*m.b32*m.b37 + 192*m.b21*m.b26*m.b33*m.b38 +
128*m.b21*m.b26*m.b34*m.b39 + 64*m.b21*m.b26*m.b35*m.b40 + 64*m.b21*m.b27*m.b28*m.b34 + 64*m.b21*
m.b27*m.b29*m.b35 + 64*m.b21*m.b27*m.b30*m.b36 + 256*m.b21*m.b27*m.b31*m.b37 + 192*m.b21*m.b27*
m.b32*m.b38 + 128*m.b21*m.b27*m.b33*m.b39 + 64*m.b21*m.b27*m.b34*m.b40 + 64*m.b21*m.b28*m.b29*
m.b36 + 256*m.b21*m.b28*m.b30*m.b37 + 192*m.b21*m.b28*m.b31*m.b38 + 128*m.b21*m.b28*m.b32*m.b39
+ 64*m.b21*m.b28*m.b33*m.b40 + 192*m.b21*m.b29*m.b30*m.b38 + 128*m.b21*m.b29*m.b31*m.b39 + 64*
m.b21*m.b29*m.b32*m.b40 + 64*m.b21*m.b30*m.b31*m.b40 + 64*m.b22*m.b23*m.b24*m.b25 + 64*m.b22*
m.b23*m.b25*m.b26 + 64*m.b22*m.b23*m.b26*m.b27 + 64*m.b22*m.b23*m.b27*m.b28 + 64*m.b22*m.b23*
m.b28*m.b29 + 64*m.b22*m.b23*m.b29*m.b30 + 64*m.b22*m.b23*m.b30*m.b31 + 64*m.b22*m.b23*m.b31*
m.b32 + 64*m.b22*m.b23*m.b32*m.b33 + 64*m.b22*m.b23*m.b33*m.b34 + 64*m.b22*m.b23*m.b34*m.b35 + 64
*m.b22*m.b23*m.b35*m.b36 + 64*m.b22*m.b23*m.b36*m.b37 + 192*m.b22*m.b23*m.b37*m.b38 + 128*m.b22*
m.b23*m.b38*m.b39 + 64*m.b22*m.b23*m.b39*m.b40 + 64*m.b22*m.b24*m.b25*m.b27 + 64*m.b22*m.b24*
m.b26*m.b28 + 64*m.b22*m.b24*m.b27*m.b29 + 64*m.b22*m.b24*m.b28*m.b30 + 64*m.b22*m.b24*m.b29*
m.b31 + 64*m.b22*m.b24*m.b30*m.b32 + 64*m.b22*m.b24*m.b31*m.b33 + 64*m.b22*m.b24*m.b32*m.b34 + 64
*m.b22*m.b24*m.b33*m.b35 + 64*m.b22*m.b24*m.b34*m.b36 + 64*m.b22*m.b24*m.b35*m.b37 + 192*m.b22*
m.b24*m.b36*m.b38 + 128*m.b22*m.b24*m.b37*m.b39 + 64*m.b22*m.b24*m.b38*m.b40 + 64*m.b22*m.b25*
m.b26*m.b29 + 64*m.b22*m.b25*m.b27*m.b30 + 64*m.b22*m.b25*m.b28*m.b31 + 64*m.b22*m.b25*m.b29*
m.b32 + 64*m.b22*m.b25*m.b30*m.b33 + 64*m.b22*m.b25*m.b31*m.b34 + 64*m.b22*m.b25*m.b32*m.b35 + 64
*m.b22*m.b25*m.b33*m.b36 + 64*m.b22*m.b25*m.b34*m.b37 + 192*m.b22*m.b25*m.b35*m.b38 + 128*m.b22*
m.b25*m.b36*m.b39 + 64*m.b22*m.b25*m.b37*m.b40 + 64*m.b22*m.b26*m.b27*m.b31 + 64*m.b22*m.b26*
m.b28*m.b32 + 64*m.b22*m.b26*m.b29*m.b33 + 64*m.b22*m.b26*m.b30*m.b34 + 64*m.b22*m.b26*m.b31*
m.b35 + 64*m.b22*m.b26*m.b32*m.b36 + 64*m.b22*m.b26*m.b33*m.b37 + 192*m.b22*m.b26*m.b34*m.b38 +
128*m.b22*m.b26*m.b35*m.b39 + 64*m.b22*m.b26*m.b36*m.b40 + 64*m.b22*m.b27*m.b28*m.b33 + 64*m.b22*
m.b27*m.b29*m.b34 + 64*m.b22*m.b27*m.b30*m.b35 + 64*m.b22*m.b27*m.b31*m.b36 + 64*m.b22*m.b27*
m.b32*m.b37 + 192*m.b22*m.b27*m.b33*m.b38 + 128*m.b22*m.b27*m.b34*m.b39 + 64*m.b22*m.b27*m.b35*
m.b40 + 64*m.b22*m.b28*m.b29*m.b35 + 64*m.b22*m.b28*m.b30*m.b36 + 64*m.b22*m.b28*m.b31*m.b37 +
192*m.b22*m.b28*m.b32*m.b38 + 128*m.b22*m.b28*m.b33*m.b39 + 64*m.b22*m.b28*m.b34*m.b40 + 64*m.b22
*m.b29*m.b30*m.b37 + 192*m.b22*m.b29*m.b31*m.b38 + 128*m.b22*m.b29*m.b32*m.b39 + 64*m.b22*m.b29*
m.b33*m.b40 + 128*m.b22*m.b30*m.b31*m.b39 + 64*m.b22*m.b30*m.b32*m.b40 + 64*m.b23*m.b24*m.b25*
m.b26 + 64*m.b23*m.b24*m.b26*m.b27 + 64*m.b23*m.b24*m.b27*m.b28 + 64*m.b23*m.b24*m.b28*m.b29 + 64
*m.b23*m.b24*m.b29*m.b30 + 64*m.b23*m.b24*m.b30*m.b31 + 64*m.b23*m.b24*m.b31*m.b32 + 64*m.b23*
m.b24*m.b32*m.b33 + 64*m.b23*m.b24*m.b33*m.b34 + 64*m.b23*m.b24*m.b34*m.b35 + 64*m.b23*m.b24*
m.b35*m.b36 + 64*m.b23*m.b24*m.b36*m.b37 + 64*m.b23*m.b24*m.b37*m.b38 + 128*m.b23*m.b24*m.b38*
m.b39 + 64*m.b23*m.b24*m.b39*m.b40 + 64*m.b23*m.b25*m.b26*m.b28 + 64*m.b23*m.b25*m.b27*m.b29 + 64
*m.b23*m.b25*m.b28*m.b30 + 64*m.b23*m.b25*m.b29*m.b31 + 64*m.b23*m.b25*m.b30*m.b32 + 64*m.b23*
m.b25*m.b31*m.b33 + 64*m.b23*m.b25*m.b32*m.b34 + 64*m.b23*m.b25*m.b33*m.b35 + 64*m.b23*m.b25*
m.b34*m.b36 + 64*m.b23*m.b25*m.b35*m.b37 + 64*m.b23*m.b25*m.b36*m.b38 + 128*m.b23*m.b25*m.b37*
m.b39 + 64*m.b23*m.b25*m.b38*m.b40 + 64*m.b23*m.b26*m.b27*m.b30 + 64*m.b23*m.b26*m.b28*m.b31 + 64
*m.b23*m.b26*m.b29*m.b32 + 64*m.b23*m.b26*m.b30*m.b33 + 64*m.b23*m.b26*m.b31*m.b34 + 64*m.b23*
m.b26*m.b32*m.b35 + 64*m.b23*m.b26*m.b33*m.b36 + 64*m.b23*m.b26*m.b34*m.b37 + 64*m.b23*m.b26*
m.b35*m.b38 + 128*m.b23*m.b26*m.b36*m.b39 + 64*m.b23*m.b26*m.b37*m.b40 + 64*m.b23*m.b27*m.b28*
m.b32 + 64*m.b23*m.b27*m.b29*m.b33 + 64*m.b23*m.b27*m.b30*m.b34 + 64*m.b23*m.b27*m.b31*m.b35 + 64
*m.b23*m.b27*m.b32*m.b36 + 64*m.b23*m.b27*m.b33*m.b37 + 64*m.b23*m.b27*m.b34*m.b38 + 128*m.b23*
m.b27*m.b35*m.b39 + 64*m.b23*m.b27*m.b36*m.b40 + 64*m.b23*m.b28*m.b29*m.b34 + 64*m.b23*m.b28*
m.b30*m.b35 + 64*m.b23*m.b28*m.b31*m.b36 + 64*m.b23*m.b28*m.b32*m.b37 + 64*m.b23*m.b28*m.b33*
m.b38 + 128*m.b23*m.b28*m.b34*m.b39 + 64*m.b23*m.b28*m.b35*m.b40 + 64*m.b23*m.b29*m.b30*m.b36 +
64*m.b23*m.b29*m.b31*m.b37 + 64*m.b23*m.b29*m.b32*m.b38 + 128*m.b23*m.b29*m.b33*m.b39 + 64*m.b23*
m.b29*m.b34*m.b40 + 64*m.b23*m.b30*m.b31*m.b38 + 128*m.b23*m.b30*m.b32*m.b39 + 64*m.b23*m.b30*
m.b33*m.b40 + 64*m.b23*m.b31*m.b32*m.b40 + 64*m.b24*m.b25*m.b26*m.b27 + 64*m.b24*m.b25*m.b27*
m.b28 + 64*m.b24*m.b25*m.b28*m.b29 + 64*m.b24*m.b25*m.b29*m.b30 + 64*m.b24*m.b25*m.b30*m.b31 + 64
*m.b24*m.b25*m.b31*m.b32 + 64*m.b24*m.b25*m.b32*m.b33 + 64*m.b24*m.b25*m.b33*m.b34 + 64*m.b24*
m.b25*m.b34*m.b35 + 64*m.b24*m.b25*m.b35*m.b36 + 64*m.b24*m.b25*m.b36*m.b37 + 64*m.b24*m.b25*
m.b37*m.b38 + 64*m.b24*m.b25*m.b38*m.b39 + 64*m.b24*m.b25*m.b39*m.b40 + 64*m.b24*m.b26*m.b27*
m.b29 + 64*m.b24*m.b26*m.b28*m.b30 + 64*m.b24*m.b26*m.b29*m.b31 + 64*m.b24*m.b26*m.b30*m.b32 + 64
*m.b24*m.b26*m.b31*m.b33 + 64*m.b24*m.b26*m.b32*m.b34 + 64*m.b24*m.b26*m.b33*m.b35 + 64*m.b24*
m.b26*m.b34*m.b36 + 64*m.b24*m.b26*m.b35*m.b37 + 64*m.b24*m.b26*m.b36*m.b38 + 64*m.b24*m.b26*
m.b37*m.b39 + 64*m.b24*m.b26*m.b38*m.b40 + 64*m.b24*m.b27*m.b28*m.b31 + 64*m.b24*m.b27*m.b29*
m.b32 + 64*m.b24*m.b27*m.b30*m.b33 + 64*m.b24*m.b27*m.b31*m.b34 + 64*m.b24*m.b27*m.b32*m.b35 + 64
*m.b24*m.b27*m.b33*m.b36 + 64*m.b24*m.b27*m.b34*m.b37 + 64*m.b24*m.b27*m.b35*m.b38 + 64*m.b24*
m.b27*m.b36*m.b39 + 64*m.b24*m.b27*m.b37*m.b40 + 64*m.b24*m.b28*m.b29*m.b33 + 64*m.b24*m.b28*
m.b30*m.b34 + 64*m.b24*m.b28*m.b31*m.b35 + 64*m.b24*m.b28*m.b32*m.b36 + 64*m.b24*m.b28*m.b33*
m.b37 + 64*m.b24*m.b28*m.b34*m.b38 + 64*m.b24*m.b28*m.b35*m.b39 + 64*m.b24*m.b28*m.b36*m.b40 + 64
*m.b24*m.b29*m.b30*m.b35 + 64*m.b24*m.b29*m.b31*m.b36 + 64*m.b24*m.b29*m.b32*m.b37 + 64*m.b24*
m.b29*m.b33*m.b38 + 64*m.b24*m.b29*m.b34*m.b39 + 64*m.b24*m.b29*m.b35*m.b40 + 64*m.b24*m.b30*
m.b31*m.b37 + 64*m.b24*m.b30*m.b32*m.b38 + 64*m.b24*m.b30*m.b33*m.b39 + 64*m.b24*m.b30*m.b34*
m.b40 + 64*m.b24*m.b31*m.b32*m.b39 + 64*m.b24*m.b31*m.b33*m.b40 + 64*m.b25*m.b26*m.b27*m.b28 + 64
*m.b25*m.b26*m.b28*m.b29 + 64*m.b25*m.b26*m.b29*m.b30 + 64*m.b25*m.b26*m.b30*m.b31 + 64*m.b25*
m.b26*m.b31*m.b32 + 64*m.b25*m.b26*m.b32*m.b33 + 64*m.b25*m.b26*m.b33*m.b34 + 64*m.b25*m.b26*
m.b34*m.b35 + 64*m.b25*m.b26*m.b35*m.b36 + 64*m.b25*m.b26*m.b36*m.b37 + 64*m.b25*m.b26*m.b37*
m.b38 + 64*m.b25*m.b26*m.b38*m.b39 + 64*m.b25*m.b26*m.b39*m.b40 + 64*m.b25*m.b27*m.b28*m.b30 + 64
*m.b25*m.b27*m.b29*m.b31 + 64*m.b25*m.b27*m.b30*m.b32 + 64*m.b25*m.b27*m.b31*m.b33 + 64*m.b25*
m.b27*m.b32*m.b34 + 64*m.b25*m.b27*m.b33*m.b35 + 64*m.b25*m.b27*m.b34*m.b36 + 64*m.b25*m.b27*
m.b35*m.b37 + 64*m.b25*m.b27*m.b36*m.b38 + 64*m.b25*m.b27*m.b37*m.b39 + 64*m.b25*m.b27*m.b38*
m.b40 + 64*m.b25*m.b28*m.b29*m.b32 + 64*m.b25*m.b28*m.b30*m.b33 + 64*m.b25*m.b28*m.b31*m.b34 + 64
*m.b25*m.b28*m.b32*m.b35 + 64*m.b25*m.b28*m.b33*m.b36 + 64*m.b25*m.b28*m.b34*m.b37 + 64*m.b25*
m.b28*m.b35*m.b38 + 64*m.b25*m.b28*m.b36*m.b39 + 64*m.b25*m.b28*m.b37*m.b40 + 64*m.b25*m.b29*
m.b30*m.b34 + 64*m.b25*m.b29*m.b31*m.b35 + 64*m.b25*m.b29*m.b32*m.b36 + 64*m.b25*m.b29*m.b33*
m.b37 + 64*m.b25*m.b29*m.b34*m.b38 + 64*m.b25*m.b29*m.b35*m.b39 + 64*m.b25*m.b29*m.b36*m.b40 + 64
*m.b25*m.b30*m.b31*m.b36 + 64*m.b25*m.b30*m.b32*m.b37 + 64*m.b25*m.b30*m.b33*m.b38 + 64*m.b25*
m.b30*m.b34*m.b39 + 64*m.b25*m.b30*m.b35*m.b40 + 64*m.b25*m.b31*m.b32*m.b38 + 64*m.b25*m.b31*
m.b33*m.b39 + 64*m.b25*m.b31*m.b34*m.b40 + 64*m.b25*m.b32*m.b33*m.b40 + 64*m.b26*m.b27*m.b28*
m.b29 + 64*m.b26*m.b27*m.b29*m.b30 + 64*m.b26*m.b27*m.b30*m.b31 + 64*m.b26*m.b27*m.b31*m.b32 + 64
*m.b26*m.b27*m.b32*m.b33 + 64*m.b26*m.b27*m.b33*m.b34 + 64*m.b26*m.b27*m.b34*m.b35 + 64*m.b26*
m.b27*m.b35*m.b36 + 64*m.b26*m.b27*m.b36*m.b37 + 64*m.b26*m.b27*m.b37*m.b38 + 64*m.b26*m.b27*
m.b38*m.b39 + 64*m.b26*m.b27*m.b39*m.b40 + 64*m.b26*m.b28*m.b29*m.b31 + 64*m.b26*m.b28*m.b30*
m.b32 + 64*m.b26*m.b28*m.b31*m.b33 + 64*m.b26*m.b28*m.b32*m.b34 + 64*m.b26*m.b28*m.b33*m.b35 + 64
*m.b26*m.b28*m.b34*m.b36 + 64*m.b26*m.b28*m.b35*m.b37 + 64*m.b26*m.b28*m.b36*m.b38 + 64*m.b26*
m.b28*m.b37*m.b39 + 64*m.b26*m.b28*m.b38*m.b40 + 64*m.b26*m.b29*m.b30*m.b33 + 64*m.b26*m.b29*
m.b31*m.b34 + 64*m.b26*m.b29*m.b32*m.b35 + 64*m.b26*m.b29*m.b33*m.b36 + 64*m.b26*m.b29*m.b34*
m.b37 + 64*m.b26*m.b29*m.b35*m.b38 + 64*m.b26*m.b29*m.b36*m.b39 + 64*m.b26*m.b29*m.b37*m.b40 + 64
*m.b26*m.b30*m.b31*m.b35 + 64*m.b26*m.b30*m.b32*m.b36 + 64*m.b26*m.b30*m.b33*m.b37 + 64*m.b26*
m.b30*m.b34*m.b38 + 64*m.b26*m.b30*m.b35*m.b39 + 64*m.b26*m.b30*m.b36*m.b40 + 64*m.b26*m.b31*
m.b32*m.b37 + 64*m.b26*m.b31*m.b33*m.b38 + 64*m.b26*m.b31*m.b34*m.b39 + 64*m.b26*m.b31*m.b35*
m.b40 + 64*m.b26*m.b32*m.b33*m.b39 + 64*m.b26*m.b32*m.b34*m.b40 + 64*m.b27*m.b28*m.b29*m.b30 + 64
*m.b27*m.b28*m.b30*m.b31 + 64*m.b27*m.b28*m.b31*m.b32 + 64*m.b27*m.b28*m.b32*m.b33 + 64*m.b27*
m.b28*m.b33*m.b34 + 64*m.b27*m.b28*m.b34*m.b35 + 64*m.b27*m.b28*m.b35*m.b36 + 64*m.b27*m.b28*
m.b36*m.b37 + 64*m.b27*m.b28*m.b37*m.b38 + 64*m.b27*m.b28*m.b38*m.b39 + 64*m.b27*m.b28*m.b39*
m.b40 + 64*m.b27*m.b29*m.b30*m.b32 + 64*m.b27*m.b29*m.b31*m.b33 + 64*m.b27*m.b29*m.b32*m.b34 + 64
*m.b27*m.b29*m.b33*m.b35 + 64*m.b27*m.b29*m.b34*m.b36 + 64*m.b27*m.b29*m.b35*m.b37 + 64*m.b27*
m.b29*m.b36*m.b38 + 64*m.b27*m.b29*m.b37*m.b39 + 64*m.b27*m.b29*m.b38*m.b40 + 64*m.b27*m.b30*
m.b31*m.b34 + 64*m.b27*m.b30*m.b32*m.b35 + 64*m.b27*m.b30*m.b33*m.b36 + 64*m.b27*m.b30*m.b34*
m.b37 + 64*m.b27*m.b30*m.b35*m.b38 + 64*m.b27*m.b30*m.b36*m.b39 + 64*m.b27*m.b30*m.b37*m.b40 + 64
*m.b27*m.b31*m.b32*m.b36 + 64*m.b27*m.b31*m.b33*m.b37 + 64*m.b27*m.b31*m.b34*m.b38 + 64*m.b27*
m.b31*m.b35*m.b39 + 64*m.b27*m.b31*m.b36*m.b40 + 64*m.b27*m.b32*m.b33*m.b38 + 64*m.b27*m.b32*
m.b34*m.b39 + 64*m.b27*m.b32*m.b35*m.b40 + 64*m.b27*m.b33*m.b34*m.b40 + 64*m.b28*m.b29*m.b30*
m.b31 + 64*m.b28*m.b29*m.b31*m.b32 + 64*m.b28*m.b29*m.b32*m.b33 + 64*m.b28*m.b29*m.b33*m.b34 + 64
*m.b28*m.b29*m.b34*m.b35 + 64*m.b28*m.b29*m.b35*m.b36 + 64*m.b28*m.b29*m.b36*m.b37 + 64*m.b28*
m.b29*m.b37*m.b38 + 64*m.b28*m.b29*m.b38*m.b39 + 64*m.b28*m.b29*m.b39*m.b40 + 64*m.b28*m.b30*
m.b31*m.b33 + 64*m.b28*m.b30*m.b32*m.b34 + 64*m.b28*m.b30*m.b33*m.b35 + 64*m.b28*m.b30*m.b34*
m.b36 + 64*m.b28*m.b30*m.b35*m.b37 + 64*m.b28*m.b30*m.b36*m.b38 + 64*m.b28*m.b30*m.b37*m.b39 + 64
*m.b28*m.b30*m.b38*m.b40 + 64*m.b28*m.b31*m.b32*m.b35 + 64*m.b28*m.b31*m.b33*m.b36 + 64*m.b28*
m.b31*m.b34*m.b37 + 64*m.b28*m.b31*m.b35*m.b38 + 64*m.b28*m.b31*m.b36*m.b39 + 64*m.b28*m.b31*
m.b37*m.b40 + 64*m.b28*m.b32*m.b33*m.b37 + 64*m.b28*m.b32*m.b34*m.b38 + 64*m.b28*m.b32*m.b35*
m.b39 + 64*m.b28*m.b32*m.b36*m.b40 + 64*m.b28*m.b33*m.b34*m.b39 + 64*m.b28*m.b33*m.b35*m.b40 + 64
*m.b29*m.b30*m.b31*m.b32 + 64*m.b29*m.b30*m.b32*m.b33 + 64*m.b29*m.b30*m.b33*m.b34 + 64*m.b29*
m.b30*m.b34*m.b35 + 64*m.b29*m.b30*m.b35*m.b36 + 64*m.b29*m.b30*m.b36*m.b37 + 64*m.b29*m.b30*
m.b37*m.b38 + 64*m.b29*m.b30*m.b38*m.b39 + 64*m.b29*m.b30*m.b39*m.b40 + 64*m.b29*m.b31*m.b32*
m.b34 + 64*m.b29*m.b31*m.b33*m.b35 + 64*m.b29*m.b31*m.b34*m.b36 + 64*m.b29*m.b31*m.b35*m.b37 + 64
*m.b29*m.b31*m.b36*m.b38 + 64*m.b29*m.b31*m.b37*m.b39 + 64*m.b29*m.b31*m.b38*m.b40 + 64*m.b29*
m.b32*m.b33*m.b36 + 64*m.b29*m.b32*m.b34*m.b37 + 64*m.b29*m.b32*m.b35*m.b38 + 64*m.b29*m.b32*
m.b36*m.b39 + 64*m.b29*m.b32*m.b37*m.b40 + 64*m.b29*m.b33*m.b34*m.b38 + 64*m.b29*m.b33*m.b35*
m.b39 + 64*m.b29*m.b33*m.b36*m.b40 + 64*m.b29*m.b34*m.b35*m.b40 + 64*m.b30*m.b31*m.b32*m.b33 + 64
*m.b30*m.b31*m.b33*m.b34 + 64*m.b30*m.b31*m.b34*m.b35 + 64*m.b30*m.b31*m.b35*m.b36 + 64*m.b30*
m.b31*m.b36*m.b37 + 64*m.b30*m.b31*m.b37*m.b38 + 64*m.b30*m.b31*m.b38*m.b39 + 64*m.b30*m.b31*
m.b39*m.b40 + 64*m.b30*m.b32*m.b33*m.b35 + 64*m.b30*m.b32*m.b34*m.b36 + 64*m.b30*m.b32*m.b35*
m.b37 + 64*m.b30*m.b32*m.b36*m.b38 + 64*m.b30*m.b32*m.b37*m.b39 + 64*m.b30*m.b32*m.b38*m.b40 + 64
*m.b30*m.b33*m.b34*m.b37 + 64*m.b30*m.b33*m.b35*m.b38 + 64*m.b30*m.b33*m.b36*m.b39 + 64*m.b30*
m.b33*m.b37*m.b40 + 64*m.b30*m.b34*m.b35*m.b39 + 64*m.b30*m.b34*m.b36*m.b40 + 64*m.b31*m.b32*
m.b33*m.b34 + 64*m.b31*m.b32*m.b34*m.b35 + 64*m.b31*m.b32*m.b35*m.b36 + 64*m.b31*m.b32*m.b36*
m.b37 + 64*m.b31*m.b32*m.b37*m.b38 + 64*m.b31*m.b32*m.b38*m.b39 + 64*m.b31*m.b32*m.b39*m.b40 + 64
*m.b31*m.b33*m.b34*m.b36 + 64*m.b31*m.b33*m.b35*m.b37 + 64*m.b31*m.b33*m.b36*m.b38 + 64*m.b31*
m.b33*m.b37*m.b39 + 64*m.b31*m.b33*m.b38*m.b40 + 64*m.b31*m.b34*m.b35*m.b38 + 64*m.b31*m.b34*
m.b36*m.b39 + 64*m.b31*m.b34*m.b37*m.b40 + 64*m.b31*m.b35*m.b36*m.b40 + 64*m.b32*m.b33*m.b34*
m.b35 + 64*m.b32*m.b33*m.b35*m.b36 + 64*m.b32*m.b33*m.b36*m.b37 + 64*m.b32*m.b33*m.b37*m.b38 + 64
*m.b32*m.b33*m.b38*m.b39 + 64*m.b32*m.b33*m.b39*m.b40 + 64*m.b32*m.b34*m.b35*m.b37 + 64*m.b32*
m.b34*m.b36*m.b38 + 64*m.b32*m.b34*m.b37*m.b39 + 64*m.b32*m.b34*m.b38*m.b40 + 64*m.b32*m.b35*
m.b36*m.b39 + 64*m.b32*m.b35*m.b37*m.b40 + 64*m.b33*m.b34*m.b35*m.b36 + 64*m.b33*m.b34*m.b36*
m.b37 + 64*m.b33*m.b34*m.b37*m.b38 + 64*m.b33*m.b34*m.b38*m.b39 + 64*m.b33*m.b34*m.b39*m.b40 + 64
*m.b33*m.b35*m.b36*m.b38 + 64*m.b33*m.b35*m.b37*m.b39 + 64*m.b33*m.b35*m.b38*m.b40 + 64*m.b33*
m.b36*m.b37*m.b40 + 64*m.b34*m.b35*m.b36*m.b37 + 64*m.b34*m.b35*m.b37*m.b38 + 64*m.b34*m.b35*
m.b38*m.b39 + 64*m.b34*m.b35*m.b39*m.b40 + 64*m.b34*m.b36*m.b37*m.b39 + 64*m.b34*m.b36*m.b38*
m.b40 + 64*m.b35*m.b36*m.b37*m.b38 + 64*m.b35*m.b36*m.b38*m.b39 + 64*m.b35*m.b36*m.b39*m.b40 + 64
*m.b35*m.b37*m.b38*m.b40 + 64*m.b36*m.b37*m.b38*m.b39 + 64*m.b36*m.b37*m.b39*m.b40 + 64*m.b37*
m.b38*m.b39*m.b40 - 32*m.b1*m.b2*m.b3 - 64*m.b1*m.b2*m.b4 - 64*m.b1*m.b2*m.b5 - 64*m.b1*m.b2*m.b6
- 64*m.b1*m.b2*m.b7 - 64*m.b1*m.b2*m.b8 - 64*m.b1*m.b2*m.b9 - 64*m.b1*m.b2*m.b10 - 64*m.b1*m.b2*
m.b11 - 64*m.b1*m.b2*m.b12 - 64*m.b1*m.b2*m.b13 - 64*m.b1*m.b2*m.b14 - 64*m.b1*m.b2*m.b15 - 64*
m.b1*m.b2*m.b16 - 64*m.b1*m.b2*m.b17 - 64*m.b1*m.b2*m.b18 - 64*m.b1*m.b2*m.b19 - 64*m.b1*m.b2*
m.b20 - 64*m.b1*m.b2*m.b21 - 64*m.b1*m.b2*m.b22 - 64*m.b1*m.b2*m.b23 - 64*m.b1*m.b2*m.b24 - 64*
m.b1*m.b2*m.b25 - 64*m.b1*m.b2*m.b26 - 64*m.b1*m.b2*m.b27 - 64*m.b1*m.b2*m.b28 - 64*m.b1*m.b2*
m.b29 - 64*m.b1*m.b2*m.b30 - 64*m.b1*m.b2*m.b31 - 64*m.b1*m.b2*m.b32 - 64*m.b1*m.b2*m.b33 - 64*
m.b1*m.b2*m.b34 - 64*m.b1*m.b2*m.b35 - 64*m.b1*m.b2*m.b36 - 64*m.b1*m.b2*m.b37 - 64*m.b1*m.b2*
m.b38 - 64*m.b1*m.b2*m.b39 - 32*m.b1*m.b2*m.b40 - 64*m.b1*m.b3*m.b4 - 32*m.b1*m.b3*m.b5 - 64*m.b1
*m.b3*m.b6 - 64*m.b1*m.b3*m.b7 - 64*m.b1*m.b3*m.b8 - 64*m.b1*m.b3*m.b9 - 64*m.b1*m.b3*m.b10 - 64*
m.b1*m.b3*m.b11 - 64*m.b1*m.b3*m.b12 - 64*m.b1*m.b3*m.b13 - 64*m.b1*m.b3*m.b14 - 64*m.b1*m.b3*
m.b15 - 64*m.b1*m.b3*m.b16 - 64*m.b1*m.b3*m.b17 - 64*m.b1*m.b3*m.b18 - 64*m.b1*m.b3*m.b19 - 64*
m.b1*m.b3*m.b20 - 64*m.b1*m.b3*m.b21 - 64*m.b1*m.b3*m.b22 - 64*m.b1*m.b3*m.b23 - 64*m.b1*m.b3*
m.b24 - 64*m.b1*m.b3*m.b25 - 64*m.b1*m.b3*m.b26 - 64*m.b1*m.b3*m.b27 - 64*m.b1*m.b3*m.b28 - 64*
m.b1*m.b3*m.b29 - 64*m.b1*m.b3*m.b30 - 64*m.b1*m.b3*m.b31 - 64*m.b1*m.b3*m.b32 - 64*m.b1*m.b3*
m.b33 - 64*m.b1*m.b3*m.b34 - 64*m.b1*m.b3*m.b35 - 64*m.b1*m.b3*m.b36 - 64*m.b1*m.b3*m.b37 - 64*
m.b1*m.b3*m.b38 - 32*m.b1*m.b3*m.b39 - 32*m.b1*m.b3*m.b40 - 64*m.b1*m.b4*m.b5 - 64*m.b1*m.b4*m.b6
- 32*m.b1*m.b4*m.b7 - 64*m.b1*m.b4*m.b8 - 64*m.b1*m.b4*m.b9 - 64*m.b1*m.b4*m.b10 - 64*m.b1*m.b4*
m.b11 - 64*m.b1*m.b4*m.b12 - 64*m.b1*m.b4*m.b13 - 64*m.b1*m.b4*m.b14 - 64*m.b1*m.b4*m.b15 - 64*
m.b1*m.b4*m.b16 - 64*m.b1*m.b4*m.b17 - 64*m.b1*m.b4*m.b18 - 64*m.b1*m.b4*m.b19 - 64*m.b1*m.b4*
m.b20 - 64*m.b1*m.b4*m.b21 - 64*m.b1*m.b4*m.b22 - 64*m.b1*m.b4*m.b23 - 64*m.b1*m.b4*m.b24 - 64*
m.b1*m.b4*m.b25 - 64*m.b1*m.b4*m.b26 - 64*m.b1*m.b4*m.b27 - 64*m.b1*m.b4*m.b28 - 64*m.b1*m.b4*
m.b29 - 64*m.b1*m.b4*m.b30 - 64*m.b1*m.b4*m.b31 - 64*m.b1*m.b4*m.b32 - 64*m.b1*m.b4*m.b33 - 64*
m.b1*m.b4*m.b34 - 64*m.b1*m.b4*m.b35 - 64*m.b1*m.b4*m.b36 - 64*m.b1*m.b4*m.b37 - 32*m.b1*m.b4*
m.b38 - 32*m.b1*m.b4*m.b39 - 32*m.b1*m.b4*m.b40 - 64*m.b1*m.b5*m.b6 - 64*m.b1*m.b5*m.b7 - 64*m.b1
*m.b5*m.b8 - 32*m.b1*m.b5*m.b9 - 64*m.b1*m.b5*m.b10 - 64*m.b1*m.b5*m.b11 - 64*m.b1*m.b5*m.b12 -
64*m.b1*m.b5*m.b13 - 64*m.b1*m.b5*m.b14 - 64*m.b1*m.b5*m.b15 - 64*m.b1*m.b5*m.b16 - 64*m.b1*m.b5*
m.b17 - 64*m.b1*m.b5*m.b18 - 64*m.b1*m.b5*m.b19 - 64*m.b1*m.b5*m.b20 - 64*m.b1*m.b5*m.b21 - 64*
m.b1*m.b5*m.b22 - 64*m.b1*m.b5*m.b23 - 64*m.b1*m.b5*m.b24 - 64*m.b1*m.b5*m.b25 - 64*m.b1*m.b5*
m.b26 - 64*m.b1*m.b5*m.b27 - 64*m.b1*m.b5*m.b28 - 64*m.b1*m.b5*m.b29 - 64*m.b1*m.b5*m.b30 - 64*
m.b1*m.b5*m.b31 - 64*m.b1*m.b5*m.b32 - 64*m.b1*m.b5*m.b33 - 64*m.b1*m.b5*m.b34 - 64*m.b1*m.b5*
m.b35 - 64*m.b1*m.b5*m.b36 - 32*m.b1*m.b5*m.b37 - 32*m.b1*m.b5*m.b38 - 32*m.b1*m.b5*m.b39 - 32*
m.b1*m.b5*m.b40 - 64*m.b1*m.b6*m.b7 - 64*m.b1*m.b6*m.b8 - 64*m.b1*m.b6*m.b9 - 64*m.b1*m.b6*m.b10
- 32*m.b1*m.b6*m.b11 - 64*m.b1*m.b6*m.b12 - 64*m.b1*m.b6*m.b13 - 64*m.b1*m.b6*m.b14 - 64*m.b1*
m.b6*m.b15 - 64*m.b1*m.b6*m.b16 - 64*m.b1*m.b6*m.b17 - 64*m.b1*m.b6*m.b18 - 64*m.b1*m.b6*m.b19 -
64*m.b1*m.b6*m.b20 - 64*m.b1*m.b6*m.b21 - 64*m.b1*m.b6*m.b22 - 64*m.b1*m.b6*m.b23 - 64*m.b1*m.b6*
m.b24 - 64*m.b1*m.b6*m.b25 - 64*m.b1*m.b6*m.b26 - 64*m.b1*m.b6*m.b27 - 64*m.b1*m.b6*m.b28 - 64*
m.b1*m.b6*m.b29 - 64*m.b1*m.b6*m.b30 - 64*m.b1*m.b6*m.b31 - 64*m.b1*m.b6*m.b32 - 64*m.b1*m.b6*
m.b33 - 64*m.b1*m.b6*m.b34 - 64*m.b1*m.b6*m.b35 - 32*m.b1*m.b6*m.b36 - 32*m.b1*m.b6*m.b37 - 32*
m.b1*m.b6*m.b38 - 32*m.b1*m.b6*m.b39 - 32*m.b1*m.b6*m.b40 - 64*m.b1*m.b7*m.b8 - 64*m.b1*m.b7*m.b9
- 64*m.b1*m.b7*m.b10 - 64*m.b1*m.b7*m.b11 - 64*m.b1*m.b7*m.b12 - 32*m.b1*m.b7*m.b13 - 64*m.b1*
m.b7*m.b14 - 64*m.b1*m.b7*m.b15 - 64*m.b1*m.b7*m.b16 - 64*m.b1*m.b7*m.b17 - 64*m.b1*m.b7*m.b18 -
64*m.b1*m.b7*m.b19 - 64*m.b1*m.b7*m.b20 - 64*m.b1*m.b7*m.b21 - 64*m.b1*m.b7*m.b22 - 64*m.b1*m.b7*
m.b23 - 64*m.b1*m.b7*m.b24 - 64*m.b1*m.b7*m.b25 - 64*m.b1*m.b7*m.b26 - 64*m.b1*m.b7*m.b27 - 64*
m.b1*m.b7*m.b28 - 64*m.b1*m.b7*m.b29 - 64*m.b1*m.b7*m.b30 - 64*m.b1*m.b7*m.b31 - 64*m.b1*m.b7*
m.b32 - 64*m.b1*m.b7*m.b33 - 64*m.b1*m.b7*m.b34 - 32*m.b1*m.b7*m.b35 - 32*m.b1*m.b7*m.b36 - 32*
m.b1*m.b7*m.b37 - 32*m.b1*m.b7*m.b38 - 32*m.b1*m.b7*m.b39 - 32*m.b1*m.b7*m.b40 - 64*m.b1*m.b8*
m.b9 - 64*m.b1*m.b8*m.b10 - 64*m.b1*m.b8*m.b11 - 64*m.b1*m.b8*m.b12 - 64*m.b1*m.b8*m.b13 - 64*
m.b1*m.b8*m.b14 - 32*m.b1*m.b8*m.b15 - 64*m.b1*m.b8*m.b16 - 64*m.b1*m.b8*m.b17 - 64*m.b1*m.b8*
m.b18 - 64*m.b1*m.b8*m.b19 - 64*m.b1*m.b8*m.b20 - 64*m.b1*m.b8*m.b21 - 64*m.b1*m.b8*m.b22 - 64*
m.b1*m.b8*m.b23 - 64*m.b1*m.b8*m.b24 - 64*m.b1*m.b8*m.b25 - 64*m.b1*m.b8*m.b26 - 64*m.b1*m.b8*
m.b27 - 64*m.b1*m.b8*m.b28 - 64*m.b1*m.b8*m.b29 - 64*m.b1*m.b8*m.b30 - 64*m.b1*m.b8*m.b31 - 64*
m.b1*m.b8*m.b32 - 64*m.b1*m.b8*m.b33 - 32*m.b1*m.b8*m.b34 - 32*m.b1*m.b8*m.b35 - 32*m.b1*m.b8*
m.b36 - 32*m.b1*m.b8*m.b37 - 32*m.b1*m.b8*m.b38 - 32*m.b1*m.b8*m.b39 - 32*m.b1*m.b8*m.b40 - 64*
m.b1*m.b9*m.b10 - 64*m.b1*m.b9*m.b11 - 64*m.b1*m.b9*m.b12 - 64*m.b1*m.b9*m.b13 - 64*m.b1*m.b9*
m.b14 - 64*m.b1*m.b9*m.b15 - 64*m.b1*m.b9*m.b16 - 32*m.b1*m.b9*m.b17 - 64*m.b1*m.b9*m.b18 - 64*
m.b1*m.b9*m.b19 - 64*m.b1*m.b9*m.b20 - 64*m.b1*m.b9*m.b21 - 64*m.b1*m.b9*m.b22 - 64*m.b1*m.b9*
m.b23 - 64*m.b1*m.b9*m.b24 - 64*m.b1*m.b9*m.b25 - 64*m.b1*m.b9*m.b26 - 64*m.b1*m.b9*m.b27 - 64*
m.b1*m.b9*m.b28 - 64*m.b1*m.b9*m.b29 - 64*m.b1*m.b9*m.b30 - 64*m.b1*m.b9*m.b31 - 64*m.b1*m.b9*
m.b32 - 32*m.b1*m.b9*m.b33 - 32*m.b1*m.b9*m.b34 - 32*m.b1*m.b9*m.b35 - 32*m.b1*m.b9*m.b36 - 32*
m.b1*m.b9*m.b37 - 32*m.b1*m.b9*m.b38 - 32*m.b1*m.b9*m.b39 - 32*m.b1*m.b9*m.b40 - 64*m.b1*m.b10*
m.b11 - 64*m.b1*m.b10*m.b12 - 64*m.b1*m.b10*m.b13 - 64*m.b1*m.b10*m.b14 - 64*m.b1*m.b10*m.b15 -
64*m.b1*m.b10*m.b16 - 64*m.b1*m.b10*m.b17 - 64*m.b1*m.b10*m.b18 - 32*m.b1*m.b10*m.b19 - 64*m.b1*
m.b10*m.b20 - 64*m.b1*m.b10*m.b21 - 64*m.b1*m.b10*m.b22 - 64*m.b1*m.b10*m.b23 - 64*m.b1*m.b10*
m.b24 - 64*m.b1*m.b10*m.b25 - 64*m.b1*m.b10*m.b26 - 64*m.b1*m.b10*m.b27 - 64*m.b1*m.b10*m.b28 -
64*m.b1*m.b10*m.b29 - 64*m.b1*m.b10*m.b30 - 64*m.b1*m.b10*m.b31 - 32*m.b1*m.b10*m.b32 - 32*m.b1*
m.b10*m.b33 - 32*m.b1*m.b10*m.b34 - 32*m.b1*m.b10*m.b35 - 32*m.b1*m.b10*m.b36 - 32*m.b1*m.b10*
m.b37 - 32*m.b1*m.b10*m.b38 - 32*m.b1*m.b10*m.b39 - 32*m.b1*m.b10*m.b40 - 64*m.b1*m.b11*m.b12 -
64*m.b1*m.b11*m.b13 - 64*m.b1*m.b11*m.b14 - 64*m.b1*m.b11*m.b15 - 64*m.b1*m.b11*m.b16 - 64*m.b1*
m.b11*m.b17 - 64*m.b1*m.b11*m.b18 - 64*m.b1*m.b11*m.b19 - 64*m.b1*m.b11*m.b20 - 32*m.b1*m.b11*
m.b21 - 64*m.b1*m.b11*m.b22 - 64*m.b1*m.b11*m.b23 - 64*m.b1*m.b11*m.b24 - 64*m.b1*m.b11*m.b25 -
64*m.b1*m.b11*m.b26 - 64*m.b1*m.b11*m.b27 - 64*m.b1*m.b11*m.b28 - 64*m.b1*m.b11*m.b29 - 64*m.b1*
m.b11*m.b30 - 32*m.b1*m.b11*m.b31 - 32*m.b1*m.b11*m.b32 - 32*m.b1*m.b11*m.b33 - 32*m.b1*m.b11*
m.b34 - 32*m.b1*m.b11*m.b35 - 32*m.b1*m.b11*m.b36 - 32*m.b1*m.b11*m.b37 - 32*m.b1*m.b11*m.b38 -
32*m.b1*m.b11*m.b39 - 32*m.b1*m.b11*m.b40 - 64*m.b1*m.b12*m.b13 - 64*m.b1*m.b12*m.b14 - 64*m.b1*
m.b12*m.b15 - 64*m.b1*m.b12*m.b16 - 64*m.b1*m.b12*m.b17 - 64*m.b1*m.b12*m.b18 - 64*m.b1*m.b12*
m.b19 - 64*m.b1*m.b12*m.b20 - 64*m.b1*m.b12*m.b21 - 64*m.b1*m.b12*m.b22 - 32*m.b1*m.b12*m.b23 -
64*m.b1*m.b12*m.b24 - 64*m.b1*m.b12*m.b25 - 64*m.b1*m.b12*m.b26 - 64*m.b1*m.b12*m.b27 - 64*m.b1*
m.b12*m.b28 - 64*m.b1*m.b12*m.b29 - 32*m.b1*m.b12*m.b30 - 32*m.b1*m.b12*m.b31 - 32*m.b1*m.b12*
m.b32 - 32*m.b1*m.b12*m.b33 - 32*m.b1*m.b12*m.b34 - 32*m.b1*m.b12*m.b35 - 32*m.b1*m.b12*m.b36 -
32*m.b1*m.b12*m.b37 - 32*m.b1*m.b12*m.b38 - 32*m.b1*m.b12*m.b39 - 32*m.b1*m.b12*m.b40 - 64*m.b1*
m.b13*m.b14 - 64*m.b1*m.b13*m.b15 - 64*m.b1*m.b13*m.b16 - 64*m.b1*m.b13*m.b17 - 64*m.b1*m.b13*
m.b18 - 64*m.b1*m.b13*m.b19 - 64*m.b1*m.b13*m.b20 - 64*m.b1*m.b13*m.b21 - 64*m.b1*m.b13*m.b22 -
64*m.b1*m.b13*m.b23 - 64*m.b1*m.b13*m.b24 - 32*m.b1*m.b13*m.b25 - 64*m.b1*m.b13*m.b26 - 64*m.b1*
m.b13*m.b27 - 64*m.b1*m.b13*m.b28 - 32*m.b1*m.b13*m.b29 - 32*m.b1*m.b13*m.b30 - 32*m.b1*m.b13*
m.b31 - 32*m.b1*m.b13*m.b32 - 32*m.b1*m.b13*m.b33 - 32*m.b1*m.b13*m.b34 - 32*m.b1*m.b13*m.b35 -
32*m.b1*m.b13*m.b36 - 32*m.b1*m.b13*m.b37 - 32*m.b1*m.b13*m.b38 - 32*m.b1*m.b13*m.b39 - 32*m.b1*
m.b13*m.b40 - 64*m.b1*m.b14*m.b15 - 64*m.b1*m.b14*m.b16 - 64*m.b1*m.b14*m.b17 - 64*m.b1*m.b14*
m.b18 - 64*m.b1*m.b14*m.b19 - 64*m.b1*m.b14*m.b20 - 64*m.b1*m.b14*m.b21 - 64*m.b1*m.b14*m.b22 -
64*m.b1*m.b14*m.b23 - 64*m.b1*m.b14*m.b24 - 64*m.b1*m.b14*m.b25 - 64*m.b1*m.b14*m.b26 - 32*m.b1*
m.b14*m.b27 - 32*m.b1*m.b14*m.b28 - 32*m.b1*m.b14*m.b29 - 32*m.b1*m.b14*m.b30 - 32*m.b1*m.b14*
m.b31 - 32*m.b1*m.b14*m.b32 - 32*m.b1*m.b14*m.b33 - 32*m.b1*m.b14*m.b34 - 32*m.b1*m.b14*m.b35 -
32*m.b1*m.b14*m.b36 - 32*m.b1*m.b14*m.b37 - 32*m.b1*m.b14*m.b38 - 32*m.b1*m.b14*m.b39 - 32*m.b1*
m.b14*m.b40 - 64*m.b1*m.b15*m.b16 - 64*m.b1*m.b15*m.b17 - 64*m.b1*m.b15*m.b18 - 64*m.b1*m.b15*
m.b19 - 64*m.b1*m.b15*m.b20 - 64*m.b1*m.b15*m.b21 - 64*m.b1*m.b15*m.b22 - 64*m.b1*m.b15*m.b23 -
64*m.b1*m.b15*m.b24 - 64*m.b1*m.b15*m.b25 - 64*m.b1*m.b15*m.b26 - 32*m.b1*m.b15*m.b27 - 32*m.b1*
m.b15*m.b28 - 32*m.b1*m.b15*m.b30 - 32*m.b1*m.b15*m.b31 - 32*m.b1*m.b15*m.b32 - 32*m.b1*m.b15*
m.b33 - 32*m.b1*m.b15*m.b34 - 32*m.b1*m.b15*m.b35 - 32*m.b1*m.b15*m.b36 - 32*m.b1*m.b15*m.b37 -
32*m.b1*m.b15*m.b38 - 32*m.b1*m.b15*m.b39 - 32*m.b1*m.b15*m.b40 - 64*m.b1*m.b16*m.b17 - 64*m.b1*
m.b16*m.b18 - 64*m.b1*m.b16*m.b19 - 64*m.b1*m.b16*m.b20 - 64*m.b1*m.b16*m.b21 - 64*m.b1*m.b16*
m.b22 - 64*m.b1*m.b16*m.b23 - 64*m.b1*m.b16*m.b24 - 64*m.b1*m.b16*m.b25 - 32*m.b1*m.b16*m.b26 -
32*m.b1*m.b16*m.b27 - 32*m.b1*m.b16*m.b28 - 32*m.b1*m.b16*m.b29 - 32*m.b1*m.b16*m.b30 - 32*m.b1*
m.b16*m.b32 - 32*m.b1*m.b16*m.b33 - 32*m.b1*m.b16*m.b34 - 32*m.b1*m.b16*m.b35 - 32*m.b1*m.b16*
m.b36 - 32*m.b1*m.b16*m.b37 - 32*m.b1*m.b16*m.b38 - 32*m.b1*m.b16*m.b39 - 32*m.b1*m.b16*m.b40 -
64*m.b1*m.b17*m.b18 - 64*m.b1*m.b17*m.b19 - 64*m.b1*m.b17*m.b20 - 64*m.b1*m.b17*m.b21 - 64*m.b1*
m.b17*m.b22 - 64*m.b1*m.b17*m.b23 - 64*m.b1*m.b17*m.b24 - 32*m.b1*m.b17*m.b25 - 32*m.b1*m.b17*
m.b26 - 32*m.b1*m.b17*m.b27 - 32*m.b1*m.b17*m.b28 - 32*m.b1*m.b17*m.b29 - 32*m.b1*m.b17*m.b30 -
32*m.b1*m.b17*m.b31 - 32*m.b1*m.b17*m.b32 - 32*m.b1*m.b17*m.b34 - 32*m.b1*m.b17*m.b35 - 32*m.b1*
m.b17*m.b36 - 32*m.b1*m.b17*m.b37 - 32*m.b1*m.b17*m.b38 - 32*m.b1*m.b17*m.b39 - 32*m.b1*m.b17*
m.b40 - 64*m.b1*m.b18*m.b19 - 64*m.b1*m.b18*m.b20 - 64*m.b1*m.b18*m.b21 - 64*m.b1*m.b18*m.b22 -
64*m.b1*m.b18*m.b23 - 32*m.b1*m.b18*m.b24 - 32*m.b1*m.b18*m.b25 - 32*m.b1*m.b18*m.b26 - 32*m.b1*
m.b18*m.b27 - 32*m.b1*m.b18*m.b28 - 32*m.b1*m.b18*m.b29 - 32*m.b1*m.b18*m.b30 - 32*m.b1*m.b18*
m.b31 - 32*m.b1*m.b18*m.b32 - 32*m.b1*m.b18*m.b33 - 32*m.b1*m.b18*m.b34 - 32*m.b1*m.b18*m.b36 -
32*m.b1*m.b18*m.b37 - 32*m.b1*m.b18*m.b38 - 32*m.b1*m.b18*m.b39 - 32*m.b1*m.b18*m.b40 - 64*m.b1*
m.b19*m.b20 - 64*m.b1*m.b19*m.b21 - 64*m.b1*m.b19*m.b22 - 32*m.b1*m.b19*m.b23 - 32*m.b1*m.b19*
m.b24 - 32*m.b1*m.b19*m.b25 - 32*m.b1*m.b19*m.b26 - 32*m.b1*m.b19*m.b27 - 32*m.b1*m.b19*m.b28 -
32*m.b1*m.b19*m.b29 - 32*m.b1*m.b19*m.b30 - 32*m.b1*m.b19*m.b31 - 32*m.b1*m.b19*m.b32 - 32*m.b1*
m.b19*m.b33 - 32*m.b1*m.b19*m.b34 - 32*m.b1*m.b19*m.b35 - 32*m.b1*m.b19*m.b36 - 32*m.b1*m.b19*
m.b38 - 32*m.b1*m.b19*m.b39 - 32*m.b1*m.b19*m.b40 - 64*m.b1*m.b20*m.b21 - 32*m.b1*m.b20*m.b22 -
32*m.b1*m.b20*m.b23 - 32*m.b1*m.b20*m.b24 - 32*m.b1*m.b20*m.b25 - 32*m.b1*m.b20*m.b26 - 32*m.b1*
m.b20*m.b27 - 32*m.b1*m.b20*m.b28 - 32*m.b1*m.b20*m.b29 - 32*m.b1*m.b20*m.b30 - 32*m.b1*m.b20*
m.b31 - 32*m.b1*m.b20*m.b32 - 32*m.b1*m.b20*m.b33 - 32*m.b1*m.b20*m.b34 - 32*m.b1*m.b20*m.b35 -
32*m.b1*m.b20*m.b36 - 32*m.b1*m.b20*m.b37 - 32*m.b1*m.b20*m.b38 - 32*m.b1*m.b20*m.b40 - 32*m.b1*
m.b21*m.b22 - 32*m.b1*m.b21*m.b23 - 32*m.b1*m.b21*m.b24 - 32*m.b1*m.b21*m.b25 - 32*m.b1*m.b21*
m.b26 - 32*m.b1*m.b21*m.b27 - 32*m.b1*m.b21*m.b28 - 32*m.b1*m.b21*m.b29 - 32*m.b1*m.b21*m.b30 -
32*m.b1*m.b21*m.b31 - 32*m.b1*m.b21*m.b32 - 32*m.b1*m.b21*m.b33 - 32*m.b1*m.b21*m.b34 - 32*m.b1*
m.b21*m.b35 - 32*m.b1*m.b21*m.b36 - 32*m.b1*m.b21*m.b37 - 32*m.b1*m.b21*m.b38 - 32*m.b1*m.b21*
m.b39 - 32*m.b1*m.b21*m.b40 - 32*m.b1*m.b22*m.b23 - 32*m.b1*m.b22*m.b24 - 32*m.b1*m.b22*m.b25 -
32*m.b1*m.b22*m.b26 - 32*m.b1*m.b22*m.b27 - 32*m.b1*m.b22*m.b28 - 32*m.b1*m.b22*m.b29 - 32*m.b1*
m.b22*m.b30 - 32*m.b1*m.b22*m.b31 - 32*m.b1*m.b22*m.b32 - 32*m.b1*m.b22*m.b33 - 32*m.b1*m.b22*
m.b34 - 32*m.b1*m.b22*m.b35 - 32*m.b1*m.b22*m.b36 - 32*m.b1*m.b22*m.b37 - 32*m.b1*m.b22*m.b38 -
32*m.b1*m.b22*m.b39 - 32*m.b1*m.b22*m.b40 - 32*m.b1*m.b23*m.b24 - 32*m.b1*m.b23*m.b25 - 32*m.b1*
m.b23*m.b26 - 32*m.b1*m.b23*m.b27 - 32*m.b1*m.b23*m.b28 - 32*m.b1*m.b23*m.b29 - 32*m.b1*m.b23*
m.b30 - 32*m.b1*m.b23*m.b31 - 32*m.b1*m.b23*m.b32 - 32*m.b1*m.b23*m.b33 - 32*m.b1*m.b23*m.b34 -
32*m.b1*m.b23*m.b35 - 32*m.b1*m.b23*m.b36 - 32*m.b1*m.b23*m.b37 - 32*m.b1*m.b23*m.b38 - 32*m.b1*
m.b23*m.b39 - 32*m.b1*m.b23*m.b40 - 32*m.b1*m.b24*m.b25 - 32*m.b1*m.b24*m.b26 - 32*m.b1*m.b24*
m.b27 - 32*m.b1*m.b24*m.b28 - 32*m.b1*m.b24*m.b29 - 32*m.b1*m.b24*m.b30 - 32*m.b1*m.b24*m.b31 -
32*m.b1*m.b24*m.b32 - 32*m.b1*m.b24*m.b33 - 32*m.b1*m.b24*m.b34 - 32*m.b1*m.b24*m.b35 - 32*m.b1*
m.b24*m.b36 - 32*m.b1*m.b24*m.b37 - 32*m.b1*m.b24*m.b38 - 32*m.b1*m.b24*m.b39 - 32*m.b1*m.b24*
m.b40 - 32*m.b1*m.b25*m.b26 - 32*m.b1*m.b25*m.b27 - 32*m.b1*m.b25*m.b28 - 32*m.b1*m.b25*m.b29 -
32*m.b1*m.b25*m.b30 - 32*m.b1*m.b25*m.b31 - 32*m.b1*m.b25*m.b32 - 32*m.b1*m.b25*m.b33 - 32*m.b1*
m.b25*m.b34 - 32*m.b1*m.b25*m.b35 - 32*m.b1*m.b25*m.b36 - 32*m.b1*m.b25*m.b37 - 32*m.b1*m.b25*
m.b38 - 32*m.b1*m.b25*m.b39 - 32*m.b1*m.b25*m.b40 - 32*m.b1*m.b26*m.b27 - 32*m.b1*m.b26*m.b28 -
32*m.b1*m.b26*m.b29 - 32*m.b1*m.b26*m.b30 - 32*m.b1*m.b26*m.b31 - 32*m.b1*m.b26*m.b32 - 32*m.b1*
m.b26*m.b33 - 32*m.b1*m.b26*m.b34 - 32*m.b1*m.b26*m.b35 - 32*m.b1*m.b26*m.b36 - 32*m.b1*m.b26*
m.b37 - 32*m.b1*m.b26*m.b38 - 32*m.b1*m.b26*m.b39 - 32*m.b1*m.b26*m.b40 - 32*m.b1*m.b27*m.b28 -
32*m.b1*m.b27*m.b29 - 32*m.b1*m.b27*m.b30 - 32*m.b1*m.b27*m.b31 - 32*m.b1*m.b27*m.b32 - 32*m.b1*
m.b27*m.b33 - 32*m.b1*m.b27*m.b34 - 32*m.b1*m.b27*m.b35 - 32*m.b1*m.b27*m.b36 - 32*m.b1*m.b27*
m.b37 - 32*m.b1*m.b27*m.b38 - 32*m.b1*m.b27*m.b39 - 32*m.b1*m.b27*m.b40 - 32*m.b1*m.b28*m.b29 -
32*m.b1*m.b28*m.b30 - 32*m.b1*m.b28*m.b31 - 32*m.b1*m.b28*m.b32 - 32*m.b1*m.b28*m.b33 - 32*m.b1*
m.b28*m.b34 - 32*m.b1*m.b28*m.b35 - 32*m.b1*m.b28*m.b36 - 32*m.b1*m.b28*m.b37 - 32*m.b1*m.b28*
m.b38 - 32*m.b1*m.b28*m.b39 - 32*m.b1*m.b28*m.b40 - 32*m.b1*m.b29*m.b30 - 32*m.b1*m.b29*m.b31 -
32*m.b1*m.b29*m.b32 - 32*m.b1*m.b29*m.b33 - 32*m.b1*m.b29*m.b34 - 32*m.b1*m.b29*m.b35 - 32*m.b1*
m.b29*m.b36 - 32*m.b1*m.b29*m.b37 - 32*m.b1*m.b29*m.b38 - 32*m.b1*m.b29*m.b39 - 32*m.b1*m.b29*
m.b40 - 32*m.b1*m.b30*m.b31 - 32*m.b1*m.b30*m.b32 - 32*m.b1*m.b30*m.b33 - 32*m.b1*m.b30*m.b34 -
32*m.b1*m.b30*m.b35 - 32*m.b1*m.b30*m.b36 - 32*m.b1*m.b30*m.b37 - 32*m.b1*m.b30*m.b38 - 32*m.b1*
m.b30*m.b39 - 32*m.b1*m.b30*m.b40 - 32*m.b1*m.b31*m.b32 - 32*m.b1*m.b31*m.b33 - 32*m.b1*m.b31*
m.b34 - 32*m.b1*m.b31*m.b35 - 32*m.b1*m.b31*m.b36 - 32*m.b1*m.b31*m.b37 - 32*m.b1*m.b31*m.b38 -
32*m.b1*m.b31*m.b39 - 32*m.b1*m.b31*m.b40 - 32*m.b1*m.b32*m.b33 - 32*m.b1*m.b32*m.b34 - 32*m.b1*
m.b32*m.b35 - 32*m.b1*m.b32*m.b36 - 32*m.b1*m.b32*m.b37 - 32*m.b1*m.b32*m.b38 - 32*m.b1*m.b32*
m.b39 - 32*m.b1*m.b32*m.b40 - 32*m.b1*m.b33*m.b34 - 32*m.b1*m.b33*m.b35 - 32*m.b1*m.b33*m.b36 -
32*m.b1*m.b33*m.b37 - 32*m.b1*m.b33*m.b38 - 32*m.b1*m.b33*m.b39 - 32*m.b1*m.b33*m.b40 - 32*m.b1*
m.b34*m.b35 - 32*m.b1*m.b34*m.b36 - 32*m.b1*m.b34*m.b37 - 32*m.b1*m.b34*m.b38 - 32*m.b1*m.b34*
m.b39 - 32*m.b1*m.b34*m.b40 - 32*m.b1*m.b35*m.b36 - 32*m.b1*m.b35*m.b37 - 32*m.b1*m.b35*m.b38 -
32*m.b1*m.b35*m.b39 - 32*m.b1*m.b35*m.b40 - 32*m.b1*m.b36*m.b37 - 32*m.b1*m.b36*m.b38 - 32*m.b1*
m.b36*m.b39 - 32*m.b1*m.b36*m.b40 - 32*m.b1*m.b37*m.b38 - 32*m.b1*m.b37*m.b39 - 32*m.b1*m.b37*
m.b40 - 32*m.b1*m.b38*m.b39 - 32*m.b1*m.b38*m.b40 - 32*m.b1*m.b39*m.b40 - 64*m.b2*m.b3*m.b4 - 64*
m.b2*m.b3*m.b5 - 64*m.b2*m.b3*m.b6 - 64*m.b2*m.b3*m.b7 - 64*m.b2*m.b3*m.b8 - 64*m.b2*m.b3*m.b9 -
64*m.b2*m.b3*m.b10 - 64*m.b2*m.b3*m.b11 - 64*m.b2*m.b3*m.b12 - 64*m.b2*m.b3*m.b13 - 64*m.b2*m.b3*
m.b14 - 64*m.b2*m.b3*m.b15 - 64*m.b2*m.b3*m.b16 - 96*m.b2*m.b3*m.b17 - 128*m.b2*m.b3*m.b18 - 128*
m.b2*m.b3*m.b19 - 128*m.b2*m.b3*m.b20 - 128*m.b2*m.b3*m.b21 - 128*m.b2*m.b3*m.b22 - 128*m.b2*m.b3
*m.b23 - 128*m.b2*m.b3*m.b24 - 128*m.b2*m.b3*m.b25 - 128*m.b2*m.b3*m.b26 - 128*m.b2*m.b3*m.b27 -
128*m.b2*m.b3*m.b28 - 128*m.b2*m.b3*m.b29 - 128*m.b2*m.b3*m.b30 - 128*m.b2*m.b3*m.b31 - 128*m.b2*
m.b3*m.b32 - 128*m.b2*m.b3*m.b33 - 128*m.b2*m.b3*m.b34 - 128*m.b2*m.b3*m.b35 - 128*m.b2*m.b3*
m.b36 - 128*m.b2*m.b3*m.b37 - 128*m.b2*m.b3*m.b38 - 96*m.b2*m.b3*m.b39 - 32*m.b2*m.b3*m.b40 - 96*
m.b2*m.b4*m.b5 - 32*m.b2*m.b4*m.b6 - 64*m.b2*m.b4*m.b7 - 64*m.b2*m.b4*m.b8 - 64*m.b2*m.b4*m.b9 -
64*m.b2*m.b4*m.b10 - 64*m.b2*m.b4*m.b11 - 64*m.b2*m.b4*m.b12 - 64*m.b2*m.b4*m.b13 - 64*m.b2*m.b4*
m.b14 - 64*m.b2*m.b4*m.b15 - 96*m.b2*m.b4*m.b16 - 96*m.b2*m.b4*m.b17 - 128*m.b2*m.b4*m.b18 - 128*
m.b2*m.b4*m.b19 - 128*m.b2*m.b4*m.b20 - 128*m.b2*m.b4*m.b21 - 128*m.b2*m.b4*m.b22 - 128*m.b2*m.b4
*m.b23 - 128*m.b2*m.b4*m.b24 - 128*m.b2*m.b4*m.b25 - 128*m.b2*m.b4*m.b26 - 128*m.b2*m.b4*m.b27 -
128*m.b2*m.b4*m.b28 - 128*m.b2*m.b4*m.b29 - 128*m.b2*m.b4*m.b30 - 128*m.b2*m.b4*m.b31 - 128*m.b2*
m.b4*m.b32 - 128*m.b2*m.b4*m.b33 - 128*m.b2*m.b4*m.b34 - 128*m.b2*m.b4*m.b35 - 128*m.b2*m.b4*
m.b36 - 128*m.b2*m.b4*m.b37 - 96*m.b2*m.b4*m.b38 - 64*m.b2*m.b4*m.b39 - 32*m.b2*m.b4*m.b40 - 96*
m.b2*m.b5*m.b6 - 64*m.b2*m.b5*m.b7 - 32*m.b2*m.b5*m.b8 - 64*m.b2*m.b5*m.b9 - 64*m.b2*m.b5*m.b10
- 64*m.b2*m.b5*m.b11 - 64*m.b2*m.b5*m.b12 - 64*m.b2*m.b5*m.b13 - 64*m.b2*m.b5*m.b14 - 96*m.b2*
m.b5*m.b15 - 96*m.b2*m.b5*m.b16 - 96*m.b2*m.b5*m.b17 - 128*m.b2*m.b5*m.b18 - 128*m.b2*m.b5*m.b19
- 128*m.b2*m.b5*m.b20 - 128*m.b2*m.b5*m.b21 - 128*m.b2*m.b5*m.b22 - 128*m.b2*m.b5*m.b23 - 128*
m.b2*m.b5*m.b24 - 128*m.b2*m.b5*m.b25 - 128*m.b2*m.b5*m.b26 - 128*m.b2*m.b5*m.b27 - 128*m.b2*m.b5
*m.b28 - 128*m.b2*m.b5*m.b29 - 128*m.b2*m.b5*m.b30 - 128*m.b2*m.b5*m.b31 - 128*m.b2*m.b5*m.b32 -
128*m.b2*m.b5*m.b33 - 128*m.b2*m.b5*m.b34 - 128*m.b2*m.b5*m.b35 - 128*m.b2*m.b5*m.b36 - 96*m.b2*
m.b5*m.b37 - 64*m.b2*m.b5*m.b38 - 64*m.b2*m.b5*m.b39 - 32*m.b2*m.b5*m.b40 - 96*m.b2*m.b6*m.b7 -
64*m.b2*m.b6*m.b8 - 64*m.b2*m.b6*m.b9 - 32*m.b2*m.b6*m.b10 - 64*m.b2*m.b6*m.b11 - 64*m.b2*m.b6*
m.b12 - 64*m.b2*m.b6*m.b13 - 96*m.b2*m.b6*m.b14 - 96*m.b2*m.b6*m.b15 - 96*m.b2*m.b6*m.b16 - 96*
m.b2*m.b6*m.b17 - 128*m.b2*m.b6*m.b18 - 128*m.b2*m.b6*m.b19 - 128*m.b2*m.b6*m.b20 - 128*m.b2*m.b6
*m.b21 - 128*m.b2*m.b6*m.b22 - 128*m.b2*m.b6*m.b23 - 128*m.b2*m.b6*m.b24 - 128*m.b2*m.b6*m.b25 -
128*m.b2*m.b6*m.b26 - 128*m.b2*m.b6*m.b27 - 128*m.b2*m.b6*m.b28 - 128*m.b2*m.b6*m.b29 - 128*m.b2*
m.b6*m.b30 - 128*m.b2*m.b6*m.b31 - 128*m.b2*m.b6*m.b32 - 128*m.b2*m.b6*m.b33 - 128*m.b2*m.b6*
m.b34 - 128*m.b2*m.b6*m.b35 - 96*m.b2*m.b6*m.b36 - 64*m.b2*m.b6*m.b37 - 64*m.b2*m.b6*m.b38 - 64*
m.b2*m.b6*m.b39 - 32*m.b2*m.b6*m.b40 - 96*m.b2*m.b7*m.b8 - 64*m.b2*m.b7*m.b9 - 64*m.b2*m.b7*m.b10
- 64*m.b2*m.b7*m.b11 - 32*m.b2*m.b7*m.b12 - 96*m.b2*m.b7*m.b13 - 96*m.b2*m.b7*m.b14 - 96*m.b2*
m.b7*m.b15 - 96*m.b2*m.b7*m.b16 - 96*m.b2*m.b7*m.b17 - 128*m.b2*m.b7*m.b18 - 128*m.b2*m.b7*m.b19
- 128*m.b2*m.b7*m.b20 - 128*m.b2*m.b7*m.b21 - 128*m.b2*m.b7*m.b22 - 128*m.b2*m.b7*m.b23 - 128*
m.b2*m.b7*m.b24 - 128*m.b2*m.b7*m.b25 - 128*m.b2*m.b7*m.b26 - 128*m.b2*m.b7*m.b27 - 128*m.b2*m.b7
*m.b28 - 128*m.b2*m.b7*m.b29 - 128*m.b2*m.b7*m.b30 - 128*m.b2*m.b7*m.b31 - 128*m.b2*m.b7*m.b32 -
128*m.b2*m.b7*m.b33 - 128*m.b2*m.b7*m.b34 - 96*m.b2*m.b7*m.b35 - 64*m.b2*m.b7*m.b36 - 64*m.b2*
m.b7*m.b37 - 64*m.b2*m.b7*m.b38 - 64*m.b2*m.b7*m.b39 - 32*m.b2*m.b7*m.b40 - 96*m.b2*m.b8*m.b9 -
64*m.b2*m.b8*m.b10 - 64*m.b2*m.b8*m.b11 - 96*m.b2*m.b8*m.b12 - 96*m.b2*m.b8*m.b13 - 64*m.b2*m.b8*
m.b14 - 96*m.b2*m.b8*m.b15 - 96*m.b2*m.b8*m.b16 - 96*m.b2*m.b8*m.b17 - 128*m.b2*m.b8*m.b18 - 128*
m.b2*m.b8*m.b19 - 128*m.b2*m.b8*m.b20 - 128*m.b2*m.b8*m.b21 - 128*m.b2*m.b8*m.b22 - 128*m.b2*m.b8
*m.b23 - 128*m.b2*m.b8*m.b24 - 128*m.b2*m.b8*m.b25 - 128*m.b2*m.b8*m.b26 - 128*m.b2*m.b8*m.b27 -
128*m.b2*m.b8*m.b28 - 128*m.b2*m.b8*m.b29 - 128*m.b2*m.b8*m.b30 - 128*m.b2*m.b8*m.b31 - 128*m.b2*
m.b8*m.b32 - 128*m.b2*m.b8*m.b33 - 96*m.b2*m.b8*m.b34 - 64*m.b2*m.b8*m.b35 - 64*m.b2*m.b8*m.b36
- 64*m.b2*m.b8*m.b37 - 64*m.b2*m.b8*m.b38 - 64*m.b2*m.b8*m.b39 - 32*m.b2*m.b8*m.b40 - 96*m.b2*
m.b9*m.b10 - 96*m.b2*m.b9*m.b11 - 96*m.b2*m.b9*m.b12 - 96*m.b2*m.b9*m.b13 - 96*m.b2*m.b9*m.b14 -
96*m.b2*m.b9*m.b15 - 64*m.b2*m.b9*m.b16 - 96*m.b2*m.b9*m.b17 - 128*m.b2*m.b9*m.b18 - 128*m.b2*
m.b9*m.b19 - 128*m.b2*m.b9*m.b20 - 128*m.b2*m.b9*m.b21 - 128*m.b2*m.b9*m.b22 - 128*m.b2*m.b9*
m.b23 - 128*m.b2*m.b9*m.b24 - 128*m.b2*m.b9*m.b25 - 128*m.b2*m.b9*m.b26 - 128*m.b2*m.b9*m.b27 -
128*m.b2*m.b9*m.b28 - 128*m.b2*m.b9*m.b29 - 128*m.b2*m.b9*m.b30 - 128*m.b2*m.b9*m.b31 - 128*m.b2*
m.b9*m.b32 - 96*m.b2*m.b9*m.b33 - 64*m.b2*m.b9*m.b34 - 64*m.b2*m.b9*m.b35 - 64*m.b2*m.b9*m.b36 -
64*m.b2*m.b9*m.b37 - 64*m.b2*m.b9*m.b38 - 64*m.b2*m.b9*m.b39 - 32*m.b2*m.b9*m.b40 - 128*m.b2*
m.b10*m.b11 - 96*m.b2*m.b10*m.b12 - 96*m.b2*m.b10*m.b13 - 96*m.b2*m.b10*m.b14 - 96*m.b2*m.b10*
m.b15 - 96*m.b2*m.b10*m.b16 - 96*m.b2*m.b10*m.b17 - 64*m.b2*m.b10*m.b18 - 128*m.b2*m.b10*m.b19 -
128*m.b2*m.b10*m.b20 - 128*m.b2*m.b10*m.b21 - 128*m.b2*m.b10*m.b22 - 128*m.b2*m.b10*m.b23 - 128*
m.b2*m.b10*m.b24 - 128*m.b2*m.b10*m.b25 - 128*m.b2*m.b10*m.b26 - 128*m.b2*m.b10*m.b27 - 128*m.b2*
m.b10*m.b28 - 128*m.b2*m.b10*m.b29 - 128*m.b2*m.b10*m.b30 - 128*m.b2*m.b10*m.b31 - 96*m.b2*m.b10*
m.b32 - 64*m.b2*m.b10*m.b33 - 64*m.b2*m.b10*m.b34 - 64*m.b2*m.b10*m.b35 - 64*m.b2*m.b10*m.b36 -
64*m.b2*m.b10*m.b37 - 64*m.b2*m.b10*m.b38 - 64*m.b2*m.b10*m.b39 - 32*m.b2*m.b10*m.b40 - 128*m.b2*
m.b11*m.b12 - 96*m.b2*m.b11*m.b13 - 96*m.b2*m.b11*m.b14 - 96*m.b2*m.b11*m.b15 - 96*m.b2*m.b11*
m.b16 - 96*m.b2*m.b11*m.b17 - 128*m.b2*m.b11*m.b18 - 128*m.b2*m.b11*m.b19 - 64*m.b2*m.b11*m.b20
- 128*m.b2*m.b11*m.b21 - 128*m.b2*m.b11*m.b22 - 128*m.b2*m.b11*m.b23 - 128*m.b2*m.b11*m.b24 -
128*m.b2*m.b11*m.b25 - 128*m.b2*m.b11*m.b26 - 128*m.b2*m.b11*m.b27 - 128*m.b2*m.b11*m.b28 - 128*
m.b2*m.b11*m.b29 - 128*m.b2*m.b11*m.b30 - 96*m.b2*m.b11*m.b31 - 64*m.b2*m.b11*m.b32 - 64*m.b2*
m.b11*m.b33 - 64*m.b2*m.b11*m.b34 - 64*m.b2*m.b11*m.b35 - 64*m.b2*m.b11*m.b36 - 64*m.b2*m.b11*
m.b37 - 64*m.b2*m.b11*m.b38 - 64*m.b2*m.b11*m.b39 - 32*m.b2*m.b11*m.b40 - 128*m.b2*m.b12*m.b13 -
96*m.b2*m.b12*m.b14 - 96*m.b2*m.b12*m.b15 - 96*m.b2*m.b12*m.b16 - 96*m.b2*m.b12*m.b17 - 128*m.b2*
m.b12*m.b18 - 128*m.b2*m.b12*m.b19 - 128*m.b2*m.b12*m.b20 - 128*m.b2*m.b12*m.b21 - 64*m.b2*m.b12*
m.b22 - 128*m.b2*m.b12*m.b23 - 128*m.b2*m.b12*m.b24 - 128*m.b2*m.b12*m.b25 - 128*m.b2*m.b12*m.b26
- 128*m.b2*m.b12*m.b27 - 128*m.b2*m.b12*m.b28 - 128*m.b2*m.b12*m.b29 - 96*m.b2*m.b12*m.b30 - 64*
m.b2*m.b12*m.b31 - 64*m.b2*m.b12*m.b32 - 64*m.b2*m.b12*m.b33 - 64*m.b2*m.b12*m.b34 - 64*m.b2*
m.b12*m.b35 - 64*m.b2*m.b12*m.b36 - 64*m.b2*m.b12*m.b37 - 64*m.b2*m.b12*m.b38 - 64*m.b2*m.b12*
m.b39 - 32*m.b2*m.b12*m.b40 - 128*m.b2*m.b13*m.b14 - 96*m.b2*m.b13*m.b15 - 96*m.b2*m.b13*m.b16 -
96*m.b2*m.b13*m.b17 - 128*m.b2*m.b13*m.b18 - 128*m.b2*m.b13*m.b19 - 128*m.b2*m.b13*m.b20 - 128*
m.b2*m.b13*m.b21 - 128*m.b2*m.b13*m.b22 - 128*m.b2*m.b13*m.b23 - 64*m.b2*m.b13*m.b24 - 128*m.b2*
m.b13*m.b25 - 128*m.b2*m.b13*m.b26 - 128*m.b2*m.b13*m.b27 - 128*m.b2*m.b13*m.b28 - 96*m.b2*m.b13*
m.b29 - 64*m.b2*m.b13*m.b30 - 64*m.b2*m.b13*m.b31 - 64*m.b2*m.b13*m.b32 - 64*m.b2*m.b13*m.b33 -
64*m.b2*m.b13*m.b34 - 64*m.b2*m.b13*m.b35 - 64*m.b2*m.b13*m.b36 - 64*m.b2*m.b13*m.b37 - 64*m.b2*
m.b13*m.b38 - 64*m.b2*m.b13*m.b39 - 32*m.b2*m.b13*m.b40 - 128*m.b2*m.b14*m.b15 - 96*m.b2*m.b14*
m.b16 - 96*m.b2*m.b14*m.b17 - 128*m.b2*m.b14*m.b18 - 128*m.b2*m.b14*m.b19 - 128*m.b2*m.b14*m.b20
- 128*m.b2*m.b14*m.b21 - 128*m.b2*m.b14*m.b22 - 128*m.b2*m.b14*m.b23 - 128*m.b2*m.b14*m.b24 -
128*m.b2*m.b14*m.b25 - 64*m.b2*m.b14*m.b26 - 128*m.b2*m.b14*m.b27 - 96*m.b2*m.b14*m.b28 - 64*m.b2
*m.b14*m.b29 - 64*m.b2*m.b14*m.b30 - 64*m.b2*m.b14*m.b31 - 64*m.b2*m.b14*m.b32 - 64*m.b2*m.b14*
m.b33 - 64*m.b2*m.b14*m.b34 - 64*m.b2*m.b14*m.b35 - 64*m.b2*m.b14*m.b36 - 64*m.b2*m.b14*m.b37 -
64*m.b2*m.b14*m.b38 - 64*m.b2*m.b14*m.b39 - 32*m.b2*m.b14*m.b40 - 128*m.b2*m.b15*m.b16 - 96*m.b2*
m.b15*m.b17 - 128*m.b2*m.b15*m.b18 - 128*m.b2*m.b15*m.b19 - 128*m.b2*m.b15*m.b20 - 128*m.b2*m.b15
*m.b21 - 128*m.b2*m.b15*m.b22 - 128*m.b2*m.b15*m.b23 - 128*m.b2*m.b15*m.b24 - 128*m.b2*m.b15*
m.b25 - 128*m.b2*m.b15*m.b26 - 96*m.b2*m.b15*m.b27 - 64*m.b2*m.b15*m.b29 - 64*m.b2*m.b15*m.b30 -
64*m.b2*m.b15*m.b31 - 64*m.b2*m.b15*m.b32 - 64*m.b2*m.b15*m.b33 - 64*m.b2*m.b15*m.b34 - 64*m.b2*
m.b15*m.b35 - 64*m.b2*m.b15*m.b36 - 64*m.b2*m.b15*m.b37 - 64*m.b2*m.b15*m.b38 - 64*m.b2*m.b15*
m.b39 - 32*m.b2*m.b15*m.b40 - 128*m.b2*m.b16*m.b17 - 128*m.b2*m.b16*m.b18 - 128*m.b2*m.b16*m.b19
- 128*m.b2*m.b16*m.b20 - 128*m.b2*m.b16*m.b21 - 128*m.b2*m.b16*m.b22 - 128*m.b2*m.b16*m.b23 -
128*m.b2*m.b16*m.b24 - 128*m.b2*m.b16*m.b25 - 96*m.b2*m.b16*m.b26 - 64*m.b2*m.b16*m.b27 - 64*m.b2
*m.b16*m.b28 - 64*m.b2*m.b16*m.b29 - 64*m.b2*m.b16*m.b31 - 64*m.b2*m.b16*m.b32 - 64*m.b2*m.b16*
m.b33 - 64*m.b2*m.b16*m.b34 - 64*m.b2*m.b16*m.b35 - 64*m.b2*m.b16*m.b36 - 64*m.b2*m.b16*m.b37 -
64*m.b2*m.b16*m.b38 - 64*m.b2*m.b16*m.b39 - 32*m.b2*m.b16*m.b40 - 160*m.b2*m.b17*m.b18 - 128*m.b2
*m.b17*m.b19 - 128*m.b2*m.b17*m.b20 - 128*m.b2*m.b17*m.b21 - 128*m.b2*m.b17*m.b22 - 128*m.b2*
m.b17*m.b23 - 128*m.b2*m.b17*m.b24 - 96*m.b2*m.b17*m.b25 - 64*m.b2*m.b17*m.b26 - 64*m.b2*m.b17*
m.b27 - 64*m.b2*m.b17*m.b28 - 64*m.b2*m.b17*m.b29 - 64*m.b2*m.b17*m.b30 - 64*m.b2*m.b17*m.b31 -
64*m.b2*m.b17*m.b33 - 64*m.b2*m.b17*m.b34 - 64*m.b2*m.b17*m.b35 - 64*m.b2*m.b17*m.b36 - 64*m.b2*
m.b17*m.b37 - 64*m.b2*m.b17*m.b38 - 64*m.b2*m.b17*m.b39 - 32*m.b2*m.b17*m.b40 - 160*m.b2*m.b18*
m.b19 - 128*m.b2*m.b18*m.b20 - 128*m.b2*m.b18*m.b21 - 128*m.b2*m.b18*m.b22 - 128*m.b2*m.b18*m.b23
- 96*m.b2*m.b18*m.b24 - 64*m.b2*m.b18*m.b25 - 64*m.b2*m.b18*m.b26 - 64*m.b2*m.b18*m.b27 - 64*
m.b2*m.b18*m.b28 - 64*m.b2*m.b18*m.b29 - 64*m.b2*m.b18*m.b30 - 64*m.b2*m.b18*m.b31 - 64*m.b2*
m.b18*m.b32 - 64*m.b2*m.b18*m.b33 - 64*m.b2*m.b18*m.b35 - 64*m.b2*m.b18*m.b36 - 64*m.b2*m.b18*
m.b37 - 64*m.b2*m.b18*m.b38 - 64*m.b2*m.b18*m.b39 - 32*m.b2*m.b18*m.b40 - 160*m.b2*m.b19*m.b20 -
128*m.b2*m.b19*m.b21 - 128*m.b2*m.b19*m.b22 - 96*m.b2*m.b19*m.b23 - 64*m.b2*m.b19*m.b24 - 64*m.b2
*m.b19*m.b25 - 64*m.b2*m.b19*m.b26 - 64*m.b2*m.b19*m.b27 - 64*m.b2*m.b19*m.b28 - 64*m.b2*m.b19*
m.b29 - 64*m.b2*m.b19*m.b30 - 64*m.b2*m.b19*m.b31 - 64*m.b2*m.b19*m.b32 - 64*m.b2*m.b19*m.b33 -
64*m.b2*m.b19*m.b34 - 64*m.b2*m.b19*m.b35 - 64*m.b2*m.b19*m.b37 - 64*m.b2*m.b19*m.b38 - 64*m.b2*
m.b19*m.b39 - 32*m.b2*m.b19*m.b40 - 160*m.b2*m.b20*m.b21 - 96*m.b2*m.b20*m.b22 - 64*m.b2*m.b20*
m.b23 - 64*m.b2*m.b20*m.b24 - 64*m.b2*m.b20*m.b25 - 64*m.b2*m.b20*m.b26 - 64*m.b2*m.b20*m.b27 -
64*m.b2*m.b20*m.b28 - 64*m.b2*m.b20*m.b29 - 64*m.b2*m.b20*m.b30 - 64*m.b2*m.b20*m.b31 - 64*m.b2*
m.b20*m.b32 - 64*m.b2*m.b20*m.b33 - 64*m.b2*m.b20*m.b34 - 64*m.b2*m.b20*m.b35 - 64*m.b2*m.b20*
m.b36 - 64*m.b2*m.b20*m.b37 - 64*m.b2*m.b20*m.b39 - 32*m.b2*m.b20*m.b40 - 96*m.b2*m.b21*m.b22 -
64*m.b2*m.b21*m.b23 - 64*m.b2*m.b21*m.b24 - 64*m.b2*m.b21*m.b25 - 64*m.b2*m.b21*m.b26 - 64*m.b2*
m.b21*m.b27 - 64*m.b2*m.b21*m.b28 - 64*m.b2*m.b21*m.b29 - 64*m.b2*m.b21*m.b30 - 64*m.b2*m.b21*
m.b31 - 64*m.b2*m.b21*m.b32 - 64*m.b2*m.b21*m.b33 - 64*m.b2*m.b21*m.b34 - 64*m.b2*m.b21*m.b35 -
64*m.b2*m.b21*m.b36 - 64*m.b2*m.b21*m.b37 - 64*m.b2*m.b21*m.b38 - 64*m.b2*m.b21*m.b39 - 96*m.b2*
m.b22*m.b23 - 64*m.b2*m.b22*m.b24 - 64*m.b2*m.b22*m.b25 - 64*m.b2*m.b22*m.b26 - 64*m.b2*m.b22*
m.b27 - 64*m.b2*m.b22*m.b28 - 64*m.b2*m.b22*m.b29 - 64*m.b2*m.b22*m.b30 - 64*m.b2*m.b22*m.b31 -
64*m.b2*m.b22*m.b32 - 64*m.b2*m.b22*m.b33 - 64*m.b2*m.b22*m.b34 - 64*m.b2*m.b22*m.b35 - 64*m.b2*
m.b22*m.b36 - 64*m.b2*m.b22*m.b37 - 64*m.b2*m.b22*m.b38 - 64*m.b2*m.b22*m.b39 - 32*m.b2*m.b22*
m.b40 - 96*m.b2*m.b23*m.b24 - 64*m.b2*m.b23*m.b25 - 64*m.b2*m.b23*m.b26 - 64*m.b2*m.b23*m.b27 -
64*m.b2*m.b23*m.b28 - 64*m.b2*m.b23*m.b29 - 64*m.b2*m.b23*m.b30 - 64*m.b2*m.b23*m.b31 - 64*m.b2*
m.b23*m.b32 - 64*m.b2*m.b23*m.b33 - 64*m.b2*m.b23*m.b34 - 64*m.b2*m.b23*m.b35 - 64*m.b2*m.b23*
m.b36 - 64*m.b2*m.b23*m.b37 - 64*m.b2*m.b23*m.b38 - 64*m.b2*m.b23*m.b39 - 32*m.b2*m.b23*m.b40 -
96*m.b2*m.b24*m.b25 - 64*m.b2*m.b24*m.b26 - 64*m.b2*m.b24*m.b27 - 64*m.b2*m.b24*m.b28 - 64*m.b2*
m.b24*m.b29 - 64*m.b2*m.b24*m.b30 - 64*m.b2*m.b24*m.b31 - 64*m.b2*m.b24*m.b32 - 64*m.b2*m.b24*
m.b33 - 64*m.b2*m.b24*m.b34 - 64*m.b2*m.b24*m.b35 - 64*m.b2*m.b24*m.b36 - 64*m.b2*m.b24*m.b37 -
64*m.b2*m.b24*m.b38 - 64*m.b2*m.b24*m.b39 - 32*m.b2*m.b24*m.b40 - 96*m.b2*m.b25*m.b26 - 64*m.b2*
m.b25*m.b27 - 64*m.b2*m.b25*m.b28 - 64*m.b2*m.b25*m.b29 - 64*m.b2*m.b25*m.b30 - 64*m.b2*m.b25*
m.b31 - 64*m.b2*m.b25*m.b32 - 64*m.b2*m.b25*m.b33 - 64*m.b2*m.b25*m.b34 - 64*m.b2*m.b25*m.b35 -
64*m.b2*m.b25*m.b36 - 64*m.b2*m.b25*m.b37 - 64*m.b2*m.b25*m.b38 - 64*m.b2*m.b25*m.b39 - 32*m.b2*
m.b25*m.b40 - 96*m.b2*m.b26*m.b27 - 64*m.b2*m.b26*m.b28 - 64*m.b2*m.b26*m.b29 - 64*m.b2*m.b26*
m.b30 - 64*m.b2*m.b26*m.b31 - 64*m.b2*m.b26*m.b32 - 64*m.b2*m.b26*m.b33 - 64*m.b2*m.b26*m.b34 -
64*m.b2*m.b26*m.b35 - 64*m.b2*m.b26*m.b36 - 64*m.b2*m.b26*m.b37 - 64*m.b2*m.b26*m.b38 - 64*m.b2*
m.b26*m.b39 - 32*m.b2*m.b26*m.b40 - 96*m.b2*m.b27*m.b28 - 64*m.b2*m.b27*m.b29 - 64*m.b2*m.b27*
m.b30 - 64*m.b2*m.b27*m.b31 - 64*m.b2*m.b27*m.b32 - 64*m.b2*m.b27*m.b33 - 64*m.b2*m.b27*m.b34 -
64*m.b2*m.b27*m.b35 - 64*m.b2*m.b27*m.b36 - 64*m.b2*m.b27*m.b37 - 64*m.b2*m.b27*m.b38 - 64*m.b2*
m.b27*m.b39 - 32*m.b2*m.b27*m.b40 - 96*m.b2*m.b28*m.b29 - 64*m.b2*m.b28*m.b30 - 64*m.b2*m.b28*
m.b31 - 64*m.b2*m.b28*m.b32 - 64*m.b2*m.b28*m.b33 - 64*m.b2*m.b28*m.b34 - 64*m.b2*m.b28*m.b35 -
64*m.b2*m.b28*m.b36 - 64*m.b2*m.b28*m.b37 - 64*m.b2*m.b28*m.b38 - 64*m.b2*m.b28*m.b39 - 32*m.b2*
m.b28*m.b40 - 96*m.b2*m.b29*m.b30 - 64*m.b2*m.b29*m.b31 - 64*m.b2*m.b29*m.b32 - 64*m.b2*m.b29*
m.b33 - 64*m.b2*m.b29*m.b34 - 64*m.b2*m.b29*m.b35 - 64*m.b2*m.b29*m.b36 - 64*m.b2*m.b29*m.b37 -
64*m.b2*m.b29*m.b38 - 64*m.b2*m.b29*m.b39 - 32*m.b2*m.b29*m.b40 - 96*m.b2*m.b30*m.b31 - 64*m.b2*
m.b30*m.b32 - 64*m.b2*m.b30*m.b33 - 64*m.b2*m.b30*m.b34 - 64*m.b2*m.b30*m.b35 - 64*m.b2*m.b30*
m.b36 - 64*m.b2*m.b30*m.b37 - 64*m.b2*m.b30*m.b38 - 64*m.b2*m.b30*m.b39 - 32*m.b2*m.b30*m.b40 -
96*m.b2*m.b31*m.b32 - 64*m.b2*m.b31*m.b33 - 64*m.b2*m.b31*m.b34 - 64*m.b2*m.b31*m.b35 - 64*m.b2*
m.b31*m.b36 - 64*m.b2*m.b31*m.b37 - 64*m.b2*m.b31*m.b38 - 64*m.b2*m.b31*m.b39 - 32*m.b2*m.b31*
m.b40 - 96*m.b2*m.b32*m.b33 - 64*m.b2*m.b32*m.b34 - 64*m.b2*m.b32*m.b35 - 64*m.b2*m.b32*m.b36 -
64*m.b2*m.b32*m.b37 - 64*m.b2*m.b32*m.b38 - 64*m.b2*m.b32*m.b39 - 32*m.b2*m.b32*m.b40 - 96*m.b2*
m.b33*m.b34 - 64*m.b2*m.b33*m.b35 - 64*m.b2*m.b33*m.b36 - 64*m.b2*m.b33*m.b37 - 64*m.b2*m.b33*
m.b38 - 64*m.b2*m.b33*m.b39 - 32*m.b2*m.b33*m.b40 - 96*m.b2*m.b34*m.b35 - 64*m.b2*m.b34*m.b36 -
64*m.b2*m.b34*m.b37 - 64*m.b2*m.b34*m.b38 - 64*m.b2*m.b34*m.b39 - 32*m.b2*m.b34*m.b40 - 96*m.b2*
m.b35*m.b36 - 64*m.b2*m.b35*m.b37 - 64*m.b2*m.b35*m.b38 - 64*m.b2*m.b35*m.b39 - 32*m.b2*m.b35*
m.b40 - 96*m.b2*m.b36*m.b37 - 64*m.b2*m.b36*m.b38 - 64*m.b2*m.b36*m.b39 - 32*m.b2*m.b36*m.b40 -
96*m.b2*m.b37*m.b38 - 64*m.b2*m.b37*m.b39 - 32*m.b2*m.b37*m.b40 - 96*m.b2*m.b38*m.b39 - 32*m.b2*
m.b38*m.b40 - 64*m.b2*m.b39*m.b40 - 64*m.b3*m.b4*m.b5 - 96*m.b3*m.b4*m.b6 - 64*m.b3*m.b4*m.b7 -
64*m.b3*m.b4*m.b8 - 64*m.b3*m.b4*m.b9 - 64*m.b3*m.b4*m.b10 - 64*m.b3*m.b4*m.b11 - 64*m.b3*m.b4*
m.b12 - 64*m.b3*m.b4*m.b13 - 64*m.b3*m.b4*m.b14 - 64*m.b3*m.b4*m.b15 - 64*m.b3*m.b4*m.b16 - 64*
m.b3*m.b4*m.b17 - 128*m.b3*m.b4*m.b18 - 192*m.b3*m.b4*m.b19 - 192*m.b3*m.b4*m.b20 - 192*m.b3*m.b4
*m.b21 - 192*m.b3*m.b4*m.b22 - 192*m.b3*m.b4*m.b23 - 192*m.b3*m.b4*m.b24 - 192*m.b3*m.b4*m.b25 -
192*m.b3*m.b4*m.b26 - 192*m.b3*m.b4*m.b27 - 192*m.b3*m.b4*m.b28 - 192*m.b3*m.b4*m.b29 - 192*m.b3*
m.b4*m.b30 - 192*m.b3*m.b4*m.b31 - 192*m.b3*m.b4*m.b32 - 192*m.b3*m.b4*m.b33 - 192*m.b3*m.b4*
m.b34 - 192*m.b3*m.b4*m.b35 - 192*m.b3*m.b4*m.b36 - 192*m.b3*m.b4*m.b37 - 160*m.b3*m.b4*m.b38 -
96*m.b3*m.b4*m.b39 - 32*m.b3*m.b4*m.b40 - 96*m.b3*m.b5*m.b6 - 64*m.b3*m.b5*m.b7 - 64*m.b3*m.b5*
m.b8 - 64*m.b3*m.b5*m.b9 - 64*m.b3*m.b5*m.b10 - 64*m.b3*m.b5*m.b11 - 64*m.b3*m.b5*m.b12 - 64*m.b3
*m.b5*m.b13 - 64*m.b3*m.b5*m.b14 - 64*m.b3*m.b5*m.b15 - 64*m.b3*m.b5*m.b16 - 128*m.b3*m.b5*m.b17
- 128*m.b3*m.b5*m.b18 - 192*m.b3*m.b5*m.b19 - 192*m.b3*m.b5*m.b20 - 192*m.b3*m.b5*m.b21 - 192*
m.b3*m.b5*m.b22 - 192*m.b3*m.b5*m.b23 - 192*m.b3*m.b5*m.b24 - 192*m.b3*m.b5*m.b25 - 192*m.b3*m.b5
*m.b26 - 192*m.b3*m.b5*m.b27 - 192*m.b3*m.b5*m.b28 - 192*m.b3*m.b5*m.b29 - 192*m.b3*m.b5*m.b30 -
192*m.b3*m.b5*m.b31 - 192*m.b3*m.b5*m.b32 - 192*m.b3*m.b5*m.b33 - 192*m.b3*m.b5*m.b34 - 192*m.b3*
m.b5*m.b35 - 192*m.b3*m.b5*m.b36 - 160*m.b3*m.b5*m.b37 - 128*m.b3*m.b5*m.b38 - 64*m.b3*m.b5*m.b39
- 32*m.b3*m.b5*m.b40 - 96*m.b3*m.b6*m.b7 - 96*m.b3*m.b6*m.b8 - 32*m.b3*m.b6*m.b9 - 64*m.b3*m.b6*
m.b10 - 64*m.b3*m.b6*m.b11 - 64*m.b3*m.b6*m.b12 - 64*m.b3*m.b6*m.b13 - 64*m.b3*m.b6*m.b14 - 64*
m.b3*m.b6*m.b15 - 128*m.b3*m.b6*m.b16 - 128*m.b3*m.b6*m.b17 - 128*m.b3*m.b6*m.b18 - 192*m.b3*m.b6
*m.b19 - 192*m.b3*m.b6*m.b20 - 192*m.b3*m.b6*m.b21 - 192*m.b3*m.b6*m.b22 - 192*m.b3*m.b6*m.b23 -
192*m.b3*m.b6*m.b24 - 192*m.b3*m.b6*m.b25 - 192*m.b3*m.b6*m.b26 - 192*m.b3*m.b6*m.b27 - 192*m.b3*
m.b6*m.b28 - 192*m.b3*m.b6*m.b29 - 192*m.b3*m.b6*m.b30 - 192*m.b3*m.b6*m.b31 - 192*m.b3*m.b6*
m.b32 - 192*m.b3*m.b6*m.b33 - 192*m.b3*m.b6*m.b34 - 192*m.b3*m.b6*m.b35 - 160*m.b3*m.b6*m.b36 -
128*m.b3*m.b6*m.b37 - 96*m.b3*m.b6*m.b38 - 64*m.b3*m.b6*m.b39 - 32*m.b3*m.b6*m.b40 - 96*m.b3*m.b7
*m.b8 - 96*m.b3*m.b7*m.b9 - 64*m.b3*m.b7*m.b10 - 32*m.b3*m.b7*m.b11 - 64*m.b3*m.b7*m.b12 - 64*
m.b3*m.b7*m.b13 - 64*m.b3*m.b7*m.b14 - 128*m.b3*m.b7*m.b15 - 128*m.b3*m.b7*m.b16 - 128*m.b3*m.b7*
m.b17 - 128*m.b3*m.b7*m.b18 - 192*m.b3*m.b7*m.b19 - 192*m.b3*m.b7*m.b20 - 192*m.b3*m.b7*m.b21 -
192*m.b3*m.b7*m.b22 - 192*m.b3*m.b7*m.b23 - 192*m.b3*m.b7*m.b24 - 192*m.b3*m.b7*m.b25 - 192*m.b3*
m.b7*m.b26 - 192*m.b3*m.b7*m.b27 - 192*m.b3*m.b7*m.b28 - 192*m.b3*m.b7*m.b29 - 192*m.b3*m.b7*
m.b30 - 192*m.b3*m.b7*m.b31 - 192*m.b3*m.b7*m.b32 - 192*m.b3*m.b7*m.b33 - 192*m.b3*m.b7*m.b34 -
160*m.b3*m.b7*m.b35 - 128*m.b3*m.b7*m.b36 - 96*m.b3*m.b7*m.b37 - 96*m.b3*m.b7*m.b38 - 64*m.b3*
m.b7*m.b39 - 32*m.b3*m.b7*m.b40 - 96*m.b3*m.b8*m.b9 - 96*m.b3*m.b8*m.b10 - 64*m.b3*m.b8*m.b11 -
64*m.b3*m.b8*m.b12 - 32*m.b3*m.b8*m.b13 - 128*m.b3*m.b8*m.b14 - 128*m.b3*m.b8*m.b15 - 128*m.b3*
m.b8*m.b16 - 128*m.b3*m.b8*m.b17 - 128*m.b3*m.b8*m.b18 - 192*m.b3*m.b8*m.b19 - 192*m.b3*m.b8*
m.b20 - 192*m.b3*m.b8*m.b21 - 192*m.b3*m.b8*m.b22 - 192*m.b3*m.b8*m.b23 - 192*m.b3*m.b8*m.b24 -
192*m.b3*m.b8*m.b25 - 192*m.b3*m.b8*m.b26 - 192*m.b3*m.b8*m.b27 - 192*m.b3*m.b8*m.b28 - 192*m.b3*
m.b8*m.b29 - 192*m.b3*m.b8*m.b30 - 192*m.b3*m.b8*m.b31 - 192*m.b3*m.b8*m.b32 - 192*m.b3*m.b8*
m.b33 - 160*m.b3*m.b8*m.b34 - 128*m.b3*m.b8*m.b35 - 96*m.b3*m.b8*m.b36 - 96*m.b3*m.b8*m.b37 - 96*
m.b3*m.b8*m.b38 - 64*m.b3*m.b8*m.b39 - 32*m.b3*m.b8*m.b40 - 96*m.b3*m.b9*m.b10 - 96*m.b3*m.b9*
m.b11 - 64*m.b3*m.b9*m.b12 - 128*m.b3*m.b9*m.b13 - 128*m.b3*m.b9*m.b14 - 96*m.b3*m.b9*m.b15 - 128
*m.b3*m.b9*m.b16 - 128*m.b3*m.b9*m.b17 - 128*m.b3*m.b9*m.b18 - 192*m.b3*m.b9*m.b19 - 192*m.b3*
m.b9*m.b20 - 192*m.b3*m.b9*m.b21 - 192*m.b3*m.b9*m.b22 - 192*m.b3*m.b9*m.b23 - 192*m.b3*m.b9*
m.b24 - 192*m.b3*m.b9*m.b25 - 192*m.b3*m.b9*m.b26 - 192*m.b3*m.b9*m.b27 - 192*m.b3*m.b9*m.b28 -
192*m.b3*m.b9*m.b29 - 192*m.b3*m.b9*m.b30 - 192*m.b3*m.b9*m.b31 - 192*m.b3*m.b9*m.b32 - 160*m.b3*
m.b9*m.b33 - 128*m.b3*m.b9*m.b34 - 96*m.b3*m.b9*m.b35 - 96*m.b3*m.b9*m.b36 - 96*m.b3*m.b9*m.b37
- 96*m.b3*m.b9*m.b38 - 64*m.b3*m.b9*m.b39 - 32*m.b3*m.b9*m.b40 - 96*m.b3*m.b10*m.b11 - 160*m.b3*
m.b10*m.b12 - 128*m.b3*m.b10*m.b13 - 128*m.b3*m.b10*m.b14 - 128*m.b3*m.b10*m.b15 - 128*m.b3*m.b10
*m.b16 - 96*m.b3*m.b10*m.b17 - 128*m.b3*m.b10*m.b18 - 192*m.b3*m.b10*m.b19 - 192*m.b3*m.b10*m.b20
- 192*m.b3*m.b10*m.b21 - 192*m.b3*m.b10*m.b22 - 192*m.b3*m.b10*m.b23 - 192*m.b3*m.b10*m.b24 -
192*m.b3*m.b10*m.b25 - 192*m.b3*m.b10*m.b26 - 192*m.b3*m.b10*m.b27 - 192*m.b3*m.b10*m.b28 - 192*
m.b3*m.b10*m.b29 - 192*m.b3*m.b10*m.b30 - 192*m.b3*m.b10*m.b31 - 160*m.b3*m.b10*m.b32 - 128*m.b3*
m.b10*m.b33 - 96*m.b3*m.b10*m.b34 - 96*m.b3*m.b10*m.b35 - 96*m.b3*m.b10*m.b36 - 96*m.b3*m.b10*
m.b37 - 96*m.b3*m.b10*m.b38 - 64*m.b3*m.b10*m.b39 - 32*m.b3*m.b10*m.b40 - 160*m.b3*m.b11*m.b12 -
160*m.b3*m.b11*m.b13 - 128*m.b3*m.b11*m.b14 - 128*m.b3*m.b11*m.b15 - 128*m.b3*m.b11*m.b16 - 128*
m.b3*m.b11*m.b17 - 128*m.b3*m.b11*m.b18 - 96*m.b3*m.b11*m.b19 - 192*m.b3*m.b11*m.b20 - 192*m.b3*
m.b11*m.b21 - 192*m.b3*m.b11*m.b22 - 192*m.b3*m.b11*m.b23 - 192*m.b3*m.b11*m.b24 - 192*m.b3*m.b11
*m.b25 - 192*m.b3*m.b11*m.b26 - 192*m.b3*m.b11*m.b27 - 192*m.b3*m.b11*m.b28 - 192*m.b3*m.b11*
m.b29 - 192*m.b3*m.b11*m.b30 - 160*m.b3*m.b11*m.b31 - 128*m.b3*m.b11*m.b32 - 96*m.b3*m.b11*m.b33
- 96*m.b3*m.b11*m.b34 - 96*m.b3*m.b11*m.b35 - 96*m.b3*m.b11*m.b36 - 96*m.b3*m.b11*m.b37 - 96*
m.b3*m.b11*m.b38 - 64*m.b3*m.b11*m.b39 - 32*m.b3*m.b11*m.b40 - 160*m.b3*m.b12*m.b13 - 160*m.b3*
m.b12*m.b14 - 128*m.b3*m.b12*m.b15 - 128*m.b3*m.b12*m.b16 - 128*m.b3*m.b12*m.b17 - 128*m.b3*m.b12
*m.b18 - 192*m.b3*m.b12*m.b19 - 192*m.b3*m.b12*m.b20 - 96*m.b3*m.b12*m.b21 - 192*m.b3*m.b12*m.b22
- 192*m.b3*m.b12*m.b23 - 192*m.b3*m.b12*m.b24 - 192*m.b3*m.b12*m.b25 - 192*m.b3*m.b12*m.b26 -
192*m.b3*m.b12*m.b27 - 192*m.b3*m.b12*m.b28 - 192*m.b3*m.b12*m.b29 - 160*m.b3*m.b12*m.b30 - 128*
m.b3*m.b12*m.b31 - 96*m.b3*m.b12*m.b32 - 96*m.b3*m.b12*m.b33 - 96*m.b3*m.b12*m.b34 - 96*m.b3*
m.b12*m.b35 - 96*m.b3*m.b12*m.b36 - 96*m.b3*m.b12*m.b37 - 96*m.b3*m.b12*m.b38 - 64*m.b3*m.b12*
m.b39 - 32*m.b3*m.b12*m.b40 - 160*m.b3*m.b13*m.b14 - 160*m.b3*m.b13*m.b15 - 128*m.b3*m.b13*m.b16
- 128*m.b3*m.b13*m.b17 - 128*m.b3*m.b13*m.b18 - 192*m.b3*m.b13*m.b19 - 192*m.b3*m.b13*m.b20 -
192*m.b3*m.b13*m.b21 - 192*m.b3*m.b13*m.b22 - 96*m.b3*m.b13*m.b23 - 192*m.b3*m.b13*m.b24 - 192*
m.b3*m.b13*m.b25 - 192*m.b3*m.b13*m.b26 - 192*m.b3*m.b13*m.b27 - 192*m.b3*m.b13*m.b28 - 160*m.b3*
m.b13*m.b29 - 128*m.b3*m.b13*m.b30 - 96*m.b3*m.b13*m.b31 - 96*m.b3*m.b13*m.b32 - 96*m.b3*m.b13*
m.b33 - 96*m.b3*m.b13*m.b34 - 96*m.b3*m.b13*m.b35 - 96*m.b3*m.b13*m.b36 - 96*m.b3*m.b13*m.b37 -
96*m.b3*m.b13*m.b38 - 64*m.b3*m.b13*m.b39 - 32*m.b3*m.b13*m.b40 - 160*m.b3*m.b14*m.b15 - 160*m.b3
*m.b14*m.b16 - 128*m.b3*m.b14*m.b17 - 128*m.b3*m.b14*m.b18 - 192*m.b3*m.b14*m.b19 - 192*m.b3*
m.b14*m.b20 - 192*m.b3*m.b14*m.b21 - 192*m.b3*m.b14*m.b22 - 192*m.b3*m.b14*m.b23 - 192*m.b3*m.b14
*m.b24 - 96*m.b3*m.b14*m.b25 - 192*m.b3*m.b14*m.b26 - 192*m.b3*m.b14*m.b27 - 160*m.b3*m.b14*m.b28
- 128*m.b3*m.b14*m.b29 - 96*m.b3*m.b14*m.b30 - 96*m.b3*m.b14*m.b31 - 96*m.b3*m.b14*m.b32 - 96*
m.b3*m.b14*m.b33 - 96*m.b3*m.b14*m.b34 - 96*m.b3*m.b14*m.b35 - 96*m.b3*m.b14*m.b36 - 96*m.b3*
m.b14*m.b37 - 96*m.b3*m.b14*m.b38 - 64*m.b3*m.b14*m.b39 - 32*m.b3*m.b14*m.b40 - 160*m.b3*m.b15*
m.b16 - 160*m.b3*m.b15*m.b17 - 128*m.b3*m.b15*m.b18 - 192*m.b3*m.b15*m.b19 - 192*m.b3*m.b15*m.b20
- 192*m.b3*m.b15*m.b21 - 192*m.b3*m.b15*m.b22 - 192*m.b3*m.b15*m.b23 - 192*m.b3*m.b15*m.b24 -
192*m.b3*m.b15*m.b25 - 192*m.b3*m.b15*m.b26 - 64*m.b3*m.b15*m.b27 - 128*m.b3*m.b15*m.b28 - 96*
m.b3*m.b15*m.b29 - 96*m.b3*m.b15*m.b30 - 96*m.b3*m.b15*m.b31 - 96*m.b3*m.b15*m.b32 - 96*m.b3*
m.b15*m.b33 - 96*m.b3*m.b15*m.b34 - 96*m.b3*m.b15*m.b35 - 96*m.b3*m.b15*m.b36 - 96*m.b3*m.b15*
m.b37 - 96*m.b3*m.b15*m.b38 - 64*m.b3*m.b15*m.b39 - 32*m.b3*m.b15*m.b40 - 160*m.b3*m.b16*m.b17 -
160*m.b3*m.b16*m.b18 - 192*m.b3*m.b16*m.b19 - 192*m.b3*m.b16*m.b20 - 192*m.b3*m.b16*m.b21 - 192*
m.b3*m.b16*m.b22 - 192*m.b3*m.b16*m.b23 - 192*m.b3*m.b16*m.b24 - 192*m.b3*m.b16*m.b25 - 160*m.b3*
m.b16*m.b26 - 128*m.b3*m.b16*m.b27 - 96*m.b3*m.b16*m.b28 - 96*m.b3*m.b16*m.b30 - 96*m.b3*m.b16*
m.b31 - 96*m.b3*m.b16*m.b32 - 96*m.b3*m.b16*m.b33 - 96*m.b3*m.b16*m.b34 - 96*m.b3*m.b16*m.b35 -
96*m.b3*m.b16*m.b36 - 96*m.b3*m.b16*m.b37 - 96*m.b3*m.b16*m.b38 - 64*m.b3*m.b16*m.b39 - 32*m.b3*
m.b16*m.b40 - 192*m.b3*m.b17*m.b18 - 224*m.b3*m.b17*m.b19 - 192*m.b3*m.b17*m.b20 - 192*m.b3*m.b17
*m.b21 - 192*m.b3*m.b17*m.b22 - 192*m.b3*m.b17*m.b23 - 192*m.b3*m.b17*m.b24 - 160*m.b3*m.b17*
m.b25 - 128*m.b3*m.b17*m.b26 - 96*m.b3*m.b17*m.b27 - 96*m.b3*m.b17*m.b28 - 96*m.b3*m.b17*m.b29 -
96*m.b3*m.b17*m.b30 - 96*m.b3*m.b17*m.b32 - 96*m.b3*m.b17*m.b33 - 96*m.b3*m.b17*m.b34 - 96*m.b3*
m.b17*m.b35 - 96*m.b3*m.b17*m.b36 - 96*m.b3*m.b17*m.b37 - 96*m.b3*m.b17*m.b38 - 64*m.b3*m.b17*
m.b39 - 32*m.b3*m.b17*m.b40 - 256*m.b3*m.b18*m.b19 - 224*m.b3*m.b18*m.b20 - 192*m.b3*m.b18*m.b21
- 192*m.b3*m.b18*m.b22 - 192*m.b3*m.b18*m.b23 - 160*m.b3*m.b18*m.b24 - 128*m.b3*m.b18*m.b25 - 96
*m.b3*m.b18*m.b26 - 96*m.b3*m.b18*m.b27 - 96*m.b3*m.b18*m.b28 - 96*m.b3*m.b18*m.b29 - 96*m.b3*
m.b18*m.b30 - 96*m.b3*m.b18*m.b31 - 96*m.b3*m.b18*m.b32 - 96*m.b3*m.b18*m.b34 - 96*m.b3*m.b18*
m.b35 - 96*m.b3*m.b18*m.b36 - 96*m.b3*m.b18*m.b37 - 96*m.b3*m.b18*m.b38 - 64*m.b3*m.b18*m.b39 -
32*m.b3*m.b18*m.b40 - 256*m.b3*m.b19*m.b20 - 224*m.b3*m.b19*m.b21 - 192*m.b3*m.b19*m.b22 - 160*
m.b3*m.b19*m.b23 - 128*m.b3*m.b19*m.b24 - 96*m.b3*m.b19*m.b25 - 96*m.b3*m.b19*m.b26 - 96*m.b3*
m.b19*m.b27 - 96*m.b3*m.b19*m.b28 - 96*m.b3*m.b19*m.b29 - 96*m.b3*m.b19*m.b30 - 96*m.b3*m.b19*
m.b31 - 96*m.b3*m.b19*m.b32 - 96*m.b3*m.b19*m.b33 - 96*m.b3*m.b19*m.b34 - 96*m.b3*m.b19*m.b36 -
96*m.b3*m.b19*m.b37 - 96*m.b3*m.b19*m.b38 - 64*m.b3*m.b19*m.b39 - 32*m.b3*m.b19*m.b40 - 256*m.b3*
m.b20*m.b21 - 192*m.b3*m.b20*m.b22 - 128*m.b3*m.b20*m.b23 - 96*m.b3*m.b20*m.b24 - 96*m.b3*m.b20*
m.b25 - 96*m.b3*m.b20*m.b26 - 96*m.b3*m.b20*m.b27 - 96*m.b3*m.b20*m.b28 - 96*m.b3*m.b20*m.b29 -
96*m.b3*m.b20*m.b30 - 96*m.b3*m.b20*m.b31 - 96*m.b3*m.b20*m.b32 - 96*m.b3*m.b20*m.b33 - 96*m.b3*
m.b20*m.b34 - 96*m.b3*m.b20*m.b35 - 96*m.b3*m.b20*m.b36 - 96*m.b3*m.b20*m.b38 - 64*m.b3*m.b20*
m.b39 - 32*m.b3*m.b20*m.b40 - 192*m.b3*m.b21*m.b22 - 128*m.b3*m.b21*m.b23 - 96*m.b3*m.b21*m.b24
- 96*m.b3*m.b21*m.b25 - 96*m.b3*m.b21*m.b26 - 96*m.b3*m.b21*m.b27 - 96*m.b3*m.b21*m.b28 - 96*
m.b3*m.b21*m.b29 - 96*m.b3*m.b21*m.b30 - 96*m.b3*m.b21*m.b31 - 96*m.b3*m.b21*m.b32 - 96*m.b3*
m.b21*m.b33 - 96*m.b3*m.b21*m.b34 - 96*m.b3*m.b21*m.b35 - 96*m.b3*m.b21*m.b36 - 96*m.b3*m.b21*
m.b37 - 96*m.b3*m.b21*m.b38 - 32*m.b3*m.b21*m.b40 - 160*m.b3*m.b22*m.b23 - 128*m.b3*m.b22*m.b24
- 96*m.b3*m.b22*m.b25 - 96*m.b3*m.b22*m.b26 - 96*m.b3*m.b22*m.b27 - 96*m.b3*m.b22*m.b28 - 96*
m.b3*m.b22*m.b29 - 96*m.b3*m.b22*m.b30 - 96*m.b3*m.b22*m.b31 - 96*m.b3*m.b22*m.b32 - 96*m.b3*
m.b22*m.b33 - 96*m.b3*m.b22*m.b34 - 96*m.b3*m.b22*m.b35 - 96*m.b3*m.b22*m.b36 - 96*m.b3*m.b22*
m.b37 - 96*m.b3*m.b22*m.b38 - 64*m.b3*m.b22*m.b39 - 32*m.b3*m.b22*m.b40 - 160*m.b3*m.b23*m.b24 -
128*m.b3*m.b23*m.b25 - 96*m.b3*m.b23*m.b26 - 96*m.b3*m.b23*m.b27 - 96*m.b3*m.b23*m.b28 - 96*m.b3*
m.b23*m.b29 - 96*m.b3*m.b23*m.b30 - 96*m.b3*m.b23*m.b31 - 96*m.b3*m.b23*m.b32 - 96*m.b3*m.b23*
m.b33 - 96*m.b3*m.b23*m.b34 - 96*m.b3*m.b23*m.b35 - 96*m.b3*m.b23*m.b36 - 96*m.b3*m.b23*m.b37 -
96*m.b3*m.b23*m.b38 - 64*m.b3*m.b23*m.b39 - 32*m.b3*m.b23*m.b40 - 160*m.b3*m.b24*m.b25 - 128*m.b3
*m.b24*m.b26 - 96*m.b3*m.b24*m.b27 - 96*m.b3*m.b24*m.b28 - 96*m.b3*m.b24*m.b29 - 96*m.b3*m.b24*
m.b30 - 96*m.b3*m.b24*m.b31 - 96*m.b3*m.b24*m.b32 - 96*m.b3*m.b24*m.b33 - 96*m.b3*m.b24*m.b34 -
96*m.b3*m.b24*m.b35 - 96*m.b3*m.b24*m.b36 - 96*m.b3*m.b24*m.b37 - 96*m.b3*m.b24*m.b38 - 64*m.b3*
m.b24*m.b39 - 32*m.b3*m.b24*m.b40 - 160*m.b3*m.b25*m.b26 - 128*m.b3*m.b25*m.b27 - 96*m.b3*m.b25*
m.b28 - 96*m.b3*m.b25*m.b29 - 96*m.b3*m.b25*m.b30 - 96*m.b3*m.b25*m.b31 - 96*m.b3*m.b25*m.b32 -
96*m.b3*m.b25*m.b33 - 96*m.b3*m.b25*m.b34 - 96*m.b3*m.b25*m.b35 - 96*m.b3*m.b25*m.b36 - 96*m.b3*
m.b25*m.b37 - 96*m.b3*m.b25*m.b38 - 64*m.b3*m.b25*m.b39 - 32*m.b3*m.b25*m.b40 - 160*m.b3*m.b26*
m.b27 - 128*m.b3*m.b26*m.b28 - 96*m.b3*m.b26*m.b29 - 96*m.b3*m.b26*m.b30 - 96*m.b3*m.b26*m.b31 -
96*m.b3*m.b26*m.b32 - 96*m.b3*m.b26*m.b33 - 96*m.b3*m.b26*m.b34 - 96*m.b3*m.b26*m.b35 - 96*m.b3*
m.b26*m.b36 - 96*m.b3*m.b26*m.b37 - 96*m.b3*m.b26*m.b38 - 64*m.b3*m.b26*m.b39 - 32*m.b3*m.b26*
m.b40 - 160*m.b3*m.b27*m.b28 - 128*m.b3*m.b27*m.b29 - 96*m.b3*m.b27*m.b30 - 96*m.b3*m.b27*m.b31
- 96*m.b3*m.b27*m.b32 - 96*m.b3*m.b27*m.b33 - 96*m.b3*m.b27*m.b34 - 96*m.b3*m.b27*m.b35 - 96*
m.b3*m.b27*m.b36 - 96*m.b3*m.b27*m.b37 - 96*m.b3*m.b27*m.b38 - 64*m.b3*m.b27*m.b39 - 32*m.b3*
m.b27*m.b40 - 160*m.b3*m.b28*m.b29 - 128*m.b3*m.b28*m.b30 - 96*m.b3*m.b28*m.b31 - 96*m.b3*m.b28*
m.b32 - 96*m.b3*m.b28*m.b33 - 96*m.b3*m.b28*m.b34 - 96*m.b3*m.b28*m.b35 - 96*m.b3*m.b28*m.b36 -
96*m.b3*m.b28*m.b37 - 96*m.b3*m.b28*m.b38 - 64*m.b3*m.b28*m.b39 - 32*m.b3*m.b28*m.b40 - 160*m.b3*
m.b29*m.b30 - 128*m.b3*m.b29*m.b31 - 96*m.b3*m.b29*m.b32 - 96*m.b3*m.b29*m.b33 - 96*m.b3*m.b29*
m.b34 - 96*m.b3*m.b29*m.b35 - 96*m.b3*m.b29*m.b36 - 96*m.b3*m.b29*m.b37 - 96*m.b3*m.b29*m.b38 -
64*m.b3*m.b29*m.b39 - 32*m.b3*m.b29*m.b40 - 160*m.b3*m.b30*m.b31 - 128*m.b3*m.b30*m.b32 - 96*m.b3
*m.b30*m.b33 - 96*m.b3*m.b30*m.b34 - 96*m.b3*m.b30*m.b35 - 96*m.b3*m.b30*m.b36 - 96*m.b3*m.b30*
m.b37 - 96*m.b3*m.b30*m.b38 - 64*m.b3*m.b30*m.b39 - 32*m.b3*m.b30*m.b40 - 160*m.b3*m.b31*m.b32 -
128*m.b3*m.b31*m.b33 - 96*m.b3*m.b31*m.b34 - 96*m.b3*m.b31*m.b35 - 96*m.b3*m.b31*m.b36 - 96*m.b3*
m.b31*m.b37 - 96*m.b3*m.b31*m.b38 - 64*m.b3*m.b31*m.b39 - 32*m.b3*m.b31*m.b40 - 160*m.b3*m.b32*
m.b33 - 128*m.b3*m.b32*m.b34 - 96*m.b3*m.b32*m.b35 - 96*m.b3*m.b32*m.b36 - 96*m.b3*m.b32*m.b37 -
96*m.b3*m.b32*m.b38 - 64*m.b3*m.b32*m.b39 - 32*m.b3*m.b32*m.b40 - 160*m.b3*m.b33*m.b34 - 128*m.b3
*m.b33*m.b35 - 96*m.b3*m.b33*m.b36 - 96*m.b3*m.b33*m.b37 - 96*m.b3*m.b33*m.b38 - 64*m.b3*m.b33*
m.b39 - 32*m.b3*m.b33*m.b40 - 160*m.b3*m.b34*m.b35 - 128*m.b3*m.b34*m.b36 - 96*m.b3*m.b34*m.b37
- 96*m.b3*m.b34*m.b38 - 64*m.b3*m.b34*m.b39 - 32*m.b3*m.b34*m.b40 - 160*m.b3*m.b35*m.b36 - 128*
m.b3*m.b35*m.b37 - 96*m.b3*m.b35*m.b38 - 64*m.b3*m.b35*m.b39 - 32*m.b3*m.b35*m.b40 - 160*m.b3*
m.b36*m.b37 - 128*m.b3*m.b36*m.b38 - 64*m.b3*m.b36*m.b39 - 32*m.b3*m.b36*m.b40 - 160*m.b3*m.b37*
m.b38 - 96*m.b3*m.b37*m.b39 - 32*m.b3*m.b37*m.b40 - 128*m.b3*m.b38*m.b39 - 64*m.b3*m.b38*m.b40 -
64*m.b3*m.b39*m.b40 - 64*m.b4*m.b5*m.b6 - 96*m.b4*m.b5*m.b7 - 96*m.b4*m.b5*m.b8 - 64*m.b4*m.b5*
m.b9 - 64*m.b4*m.b5*m.b10 - 64*m.b4*m.b5*m.b11 - 64*m.b4*m.b5*m.b12 - 64*m.b4*m.b5*m.b13 - 64*
m.b4*m.b5*m.b14 - 64*m.b4*m.b5*m.b15 - 64*m.b4*m.b5*m.b16 - 64*m.b4*m.b5*m.b17 - 64*m.b4*m.b5*
m.b18 - 160*m.b4*m.b5*m.b19 - 256*m.b4*m.b5*m.b20 - 256*m.b4*m.b5*m.b21 - 256*m.b4*m.b5*m.b22 -
256*m.b4*m.b5*m.b23 - 256*m.b4*m.b5*m.b24 - 256*m.b4*m.b5*m.b25 - 256*m.b4*m.b5*m.b26 - 256*m.b4*
m.b5*m.b27 - 256*m.b4*m.b5*m.b28 - 256*m.b4*m.b5*m.b29 - 256*m.b4*m.b5*m.b30 - 256*m.b4*m.b5*
m.b31 - 256*m.b4*m.b5*m.b32 - 256*m.b4*m.b5*m.b33 - 256*m.b4*m.b5*m.b34 - 256*m.b4*m.b5*m.b35 -
256*m.b4*m.b5*m.b36 - 224*m.b4*m.b5*m.b37 - 160*m.b4*m.b5*m.b38 - 96*m.b4*m.b5*m.b39 - 32*m.b4*
m.b5*m.b40 - 96*m.b4*m.b6*m.b7 - 64*m.b4*m.b6*m.b8 - 96*m.b4*m.b6*m.b9 - 64*m.b4*m.b6*m.b10 - 64*
m.b4*m.b6*m.b11 - 64*m.b4*m.b6*m.b12 - 64*m.b4*m.b6*m.b13 - 64*m.b4*m.b6*m.b14 - 64*m.b4*m.b6*
m.b15 - 64*m.b4*m.b6*m.b16 - 64*m.b4*m.b6*m.b17 - 160*m.b4*m.b6*m.b18 - 160*m.b4*m.b6*m.b19 - 256
*m.b4*m.b6*m.b20 - 256*m.b4*m.b6*m.b21 - 256*m.b4*m.b6*m.b22 - 256*m.b4*m.b6*m.b23 - 256*m.b4*
m.b6*m.b24 - 256*m.b4*m.b6*m.b25 - 256*m.b4*m.b6*m.b26 - 256*m.b4*m.b6*m.b27 - 256*m.b4*m.b6*
m.b28 - 256*m.b4*m.b6*m.b29 - 256*m.b4*m.b6*m.b30 - 256*m.b4*m.b6*m.b31 - 256*m.b4*m.b6*m.b32 -
256*m.b4*m.b6*m.b33 - 256*m.b4*m.b6*m.b34 - 256*m.b4*m.b6*m.b35 - 224*m.b4*m.b6*m.b36 - 192*m.b4*
m.b6*m.b37 - 128*m.b4*m.b6*m.b38 - 64*m.b4*m.b6*m.b39 - 32*m.b4*m.b6*m.b40 - 96*m.b4*m.b7*m.b8 -
96*m.b4*m.b7*m.b9 - 64*m.b4*m.b7*m.b10 - 64*m.b4*m.b7*m.b11 - 64*m.b4*m.b7*m.b12 - 64*m.b4*m.b7*
m.b13 - 64*m.b4*m.b7*m.b14 - 64*m.b4*m.b7*m.b15 - 64*m.b4*m.b7*m.b16 - 160*m.b4*m.b7*m.b17 - 160*
m.b4*m.b7*m.b18 - 160*m.b4*m.b7*m.b19 - 256*m.b4*m.b7*m.b20 - 256*m.b4*m.b7*m.b21 - 256*m.b4*m.b7
*m.b22 - 256*m.b4*m.b7*m.b23 - 256*m.b4*m.b7*m.b24 - 256*m.b4*m.b7*m.b25 - 256*m.b4*m.b7*m.b26 -
256*m.b4*m.b7*m.b27 - 256*m.b4*m.b7*m.b28 - 256*m.b4*m.b7*m.b29 - 256*m.b4*m.b7*m.b30 - 256*m.b4*
m.b7*m.b31 - 256*m.b4*m.b7*m.b32 - 256*m.b4*m.b7*m.b33 - 256*m.b4*m.b7*m.b34 - 224*m.b4*m.b7*
m.b35 - 192*m.b4*m.b7*m.b36 - 160*m.b4*m.b7*m.b37 - 96*m.b4*m.b7*m.b38 - 64*m.b4*m.b7*m.b39 - 32*
m.b4*m.b7*m.b40 - 96*m.b4*m.b8*m.b9 - 96*m.b4*m.b8*m.b10 - 96*m.b4*m.b8*m.b11 - 32*m.b4*m.b8*
m.b12 - 64*m.b4*m.b8*m.b13 - 64*m.b4*m.b8*m.b14 - 64*m.b4*m.b8*m.b15 - 160*m.b4*m.b8*m.b16 - 160*
m.b4*m.b8*m.b17 - 160*m.b4*m.b8*m.b18 - 160*m.b4*m.b8*m.b19 - 256*m.b4*m.b8*m.b20 - 256*m.b4*m.b8
*m.b21 - 256*m.b4*m.b8*m.b22 - 256*m.b4*m.b8*m.b23 - 256*m.b4*m.b8*m.b24 - 256*m.b4*m.b8*m.b25 -
256*m.b4*m.b8*m.b26 - 256*m.b4*m.b8*m.b27 - 256*m.b4*m.b8*m.b28 - 256*m.b4*m.b8*m.b29 - 256*m.b4*
m.b8*m.b30 - 256*m.b4*m.b8*m.b31 - 256*m.b4*m.b8*m.b32 - 256*m.b4*m.b8*m.b33 - 224*m.b4*m.b8*
m.b34 - 192*m.b4*m.b8*m.b35 - 160*m.b4*m.b8*m.b36 - 128*m.b4*m.b8*m.b37 - 96*m.b4*m.b8*m.b38 - 64
*m.b4*m.b8*m.b39 - 32*m.b4*m.b8*m.b40 - 96*m.b4*m.b9*m.b10 - 96*m.b4*m.b9*m.b11 - 96*m.b4*m.b9*
m.b12 - 64*m.b4*m.b9*m.b13 - 32*m.b4*m.b9*m.b14 - 160*m.b4*m.b9*m.b15 - 160*m.b4*m.b9*m.b16 - 160
*m.b4*m.b9*m.b17 - 160*m.b4*m.b9*m.b18 - 160*m.b4*m.b9*m.b19 - 256*m.b4*m.b9*m.b20 - 256*m.b4*
m.b9*m.b21 - 256*m.b4*m.b9*m.b22 - 256*m.b4*m.b9*m.b23 - 256*m.b4*m.b9*m.b24 - 256*m.b4*m.b9*
m.b25 - 256*m.b4*m.b9*m.b26 - 256*m.b4*m.b9*m.b27 - 256*m.b4*m.b9*m.b28 - 256*m.b4*m.b9*m.b29 -
256*m.b4*m.b9*m.b30 - 256*m.b4*m.b9*m.b31 - 256*m.b4*m.b9*m.b32 - 224*m.b4*m.b9*m.b33 - 192*m.b4*
m.b9*m.b34 - 160*m.b4*m.b9*m.b35 - 128*m.b4*m.b9*m.b36 - 128*m.b4*m.b9*m.b37 - 96*m.b4*m.b9*m.b38
- 64*m.b4*m.b9*m.b39 - 32*m.b4*m.b9*m.b40 - 96*m.b4*m.b10*m.b11 - 96*m.b4*m.b10*m.b12 - 96*m.b4*
m.b10*m.b13 - 160*m.b4*m.b10*m.b14 - 160*m.b4*m.b10*m.b15 - 128*m.b4*m.b10*m.b16 - 160*m.b4*m.b10
*m.b17 - 160*m.b4*m.b10*m.b18 - 160*m.b4*m.b10*m.b19 - 256*m.b4*m.b10*m.b20 - 256*m.b4*m.b10*
m.b21 - 256*m.b4*m.b10*m.b22 - 256*m.b4*m.b10*m.b23 - 256*m.b4*m.b10*m.b24 - 256*m.b4*m.b10*m.b25
- 256*m.b4*m.b10*m.b26 - 256*m.b4*m.b10*m.b27 - 256*m.b4*m.b10*m.b28 - 256*m.b4*m.b10*m.b29 -
256*m.b4*m.b10*m.b30 - 256*m.b4*m.b10*m.b31 - 224*m.b4*m.b10*m.b32 - 192*m.b4*m.b10*m.b33 - 160*
m.b4*m.b10*m.b34 - 128*m.b4*m.b10*m.b35 - 128*m.b4*m.b10*m.b36 - 128*m.b4*m.b10*m.b37 - 96*m.b4*
m.b10*m.b38 - 64*m.b4*m.b10*m.b39 - 32*m.b4*m.b10*m.b40 - 96*m.b4*m.b11*m.b12 - 192*m.b4*m.b11*
m.b13 - 192*m.b4*m.b11*m.b14 - 160*m.b4*m.b11*m.b15 - 160*m.b4*m.b11*m.b16 - 160*m.b4*m.b11*m.b17
- 128*m.b4*m.b11*m.b18 - 160*m.b4*m.b11*m.b19 - 256*m.b4*m.b11*m.b20 - 256*m.b4*m.b11*m.b21 -
256*m.b4*m.b11*m.b22 - 256*m.b4*m.b11*m.b23 - 256*m.b4*m.b11*m.b24 - 256*m.b4*m.b11*m.b25 - 256*
m.b4*m.b11*m.b26 - 256*m.b4*m.b11*m.b27 - 256*m.b4*m.b11*m.b28 - 256*m.b4*m.b11*m.b29 - 256*m.b4*
m.b11*m.b30 - 224*m.b4*m.b11*m.b31 - 192*m.b4*m.b11*m.b32 - 160*m.b4*m.b11*m.b33 - 128*m.b4*m.b11
*m.b34 - 128*m.b4*m.b11*m.b35 - 128*m.b4*m.b11*m.b36 - 128*m.b4*m.b11*m.b37 - 96*m.b4*m.b11*m.b38
- 64*m.b4*m.b11*m.b39 - 32*m.b4*m.b11*m.b40 - 192*m.b4*m.b12*m.b13 - 192*m.b4*m.b12*m.b14 - 192*
m.b4*m.b12*m.b15 - 160*m.b4*m.b12*m.b16 - 160*m.b4*m.b12*m.b17 - 160*m.b4*m.b12*m.b18 - 160*m.b4*
m.b12*m.b19 - 128*m.b4*m.b12*m.b20 - 256*m.b4*m.b12*m.b21 - 256*m.b4*m.b12*m.b22 - 256*m.b4*m.b12
*m.b23 - 256*m.b4*m.b12*m.b24 - 256*m.b4*m.b12*m.b25 - 256*m.b4*m.b12*m.b26 - 256*m.b4*m.b12*
m.b27 - 256*m.b4*m.b12*m.b28 - 256*m.b4*m.b12*m.b29 - 224*m.b4*m.b12*m.b30 - 192*m.b4*m.b12*m.b31
- 160*m.b4*m.b12*m.b32 - 128*m.b4*m.b12*m.b33 - 128*m.b4*m.b12*m.b34 - 128*m.b4*m.b12*m.b35 -
128*m.b4*m.b12*m.b36 - 128*m.b4*m.b12*m.b37 - 96*m.b4*m.b12*m.b38 - 64*m.b4*m.b12*m.b39 - 32*m.b4
*m.b12*m.b40 - 192*m.b4*m.b13*m.b14 - 192*m.b4*m.b13*m.b15 - 192*m.b4*m.b13*m.b16 - 160*m.b4*
m.b13*m.b17 - 160*m.b4*m.b13*m.b18 - 160*m.b4*m.b13*m.b19 - 256*m.b4*m.b13*m.b20 - 256*m.b4*m.b13
*m.b21 - 128*m.b4*m.b13*m.b22 - 256*m.b4*m.b13*m.b23 - 256*m.b4*m.b13*m.b24 - 256*m.b4*m.b13*
m.b25 - 256*m.b4*m.b13*m.b26 - 256*m.b4*m.b13*m.b27 - 256*m.b4*m.b13*m.b28 - 224*m.b4*m.b13*m.b29
- 192*m.b4*m.b13*m.b30 - 160*m.b4*m.b13*m.b31 - 128*m.b4*m.b13*m.b32 - 128*m.b4*m.b13*m.b33 -
128*m.b4*m.b13*m.b34 - 128*m.b4*m.b13*m.b35 - 128*m.b4*m.b13*m.b36 - 128*m.b4*m.b13*m.b37 - 96*
m.b4*m.b13*m.b38 - 64*m.b4*m.b13*m.b39 - 32*m.b4*m.b13*m.b40 - 192*m.b4*m.b14*m.b15 - 192*m.b4*
m.b14*m.b16 - 192*m.b4*m.b14*m.b17 - 160*m.b4*m.b14*m.b18 - 160*m.b4*m.b14*m.b19 - 256*m.b4*m.b14
*m.b20 - 256*m.b4*m.b14*m.b21 - 256*m.b4*m.b14*m.b22 - 256*m.b4*m.b14*m.b23 - 128*m.b4*m.b14*
m.b24 - 256*m.b4*m.b14*m.b25 - 256*m.b4*m.b14*m.b26 - 256*m.b4*m.b14*m.b27 - 224*m.b4*m.b14*m.b28
- 192*m.b4*m.b14*m.b29 - 160*m.b4*m.b14*m.b30 - 128*m.b4*m.b14*m.b31 - 128*m.b4*m.b14*m.b32 -
128*m.b4*m.b14*m.b33 - 128*m.b4*m.b14*m.b34 - 128*m.b4*m.b14*m.b35 - 128*m.b4*m.b14*m.b36 - 128*
m.b4*m.b14*m.b37 - 96*m.b4*m.b14*m.b38 - 64*m.b4*m.b14*m.b39 - 32*m.b4*m.b14*m.b40 - 192*m.b4*
m.b15*m.b16 - 192*m.b4*m.b15*m.b17 - 192*m.b4*m.b15*m.b18 - 160*m.b4*m.b15*m.b19 - 256*m.b4*m.b15
*m.b20 - 256*m.b4*m.b15*m.b21 - 256*m.b4*m.b15*m.b22 - 256*m.b4*m.b15*m.b23 - 256*m.b4*m.b15*
m.b24 - 256*m.b4*m.b15*m.b25 - 128*m.b4*m.b15*m.b26 - 224*m.b4*m.b15*m.b27 - 192*m.b4*m.b15*m.b28
- 160*m.b4*m.b15*m.b29 - 128*m.b4*m.b15*m.b30 - 128*m.b4*m.b15*m.b31 - 128*m.b4*m.b15*m.b32 -
128*m.b4*m.b15*m.b33 - 128*m.b4*m.b15*m.b34 - 128*m.b4*m.b15*m.b35 - 128*m.b4*m.b15*m.b36 - 128*
m.b4*m.b15*m.b37 - 96*m.b4*m.b15*m.b38 - 64*m.b4*m.b15*m.b39 - 32*m.b4*m.b15*m.b40 - 192*m.b4*
m.b16*m.b17 - 224*m.b4*m.b16*m.b18 - 192*m.b4*m.b16*m.b19 - 256*m.b4*m.b16*m.b20 - 256*m.b4*m.b16
*m.b21 - 256*m.b4*m.b16*m.b22 - 256*m.b4*m.b16*m.b23 - 256*m.b4*m.b16*m.b24 - 256*m.b4*m.b16*
m.b25 - 224*m.b4*m.b16*m.b26 - 192*m.b4*m.b16*m.b27 - 32*m.b4*m.b16*m.b28 - 128*m.b4*m.b16*m.b29
- 128*m.b4*m.b16*m.b30 - 128*m.b4*m.b16*m.b31 - 128*m.b4*m.b16*m.b32 - 128*m.b4*m.b16*m.b33 -
128*m.b4*m.b16*m.b34 - 128*m.b4*m.b16*m.b35 - 128*m.b4*m.b16*m.b36 - 128*m.b4*m.b16*m.b37 - 96*
m.b4*m.b16*m.b38 - 64*m.b4*m.b16*m.b39 - 32*m.b4*m.b16*m.b40 - 192*m.b4*m.b17*m.b18 - 224*m.b4*
m.b17*m.b19 - 288*m.b4*m.b17*m.b20 - 256*m.b4*m.b17*m.b21 - 256*m.b4*m.b17*m.b22 - 256*m.b4*m.b17
*m.b23 - 256*m.b4*m.b17*m.b24 - 224*m.b4*m.b17*m.b25 - 192*m.b4*m.b17*m.b26 - 160*m.b4*m.b17*
m.b27 - 128*m.b4*m.b17*m.b28 - 128*m.b4*m.b17*m.b29 - 128*m.b4*m.b17*m.b31 - 128*m.b4*m.b17*m.b32
- 128*m.b4*m.b17*m.b33 - 128*m.b4*m.b17*m.b34 - 128*m.b4*m.b17*m.b35 - 128*m.b4*m.b17*m.b36 -
128*m.b4*m.b17*m.b37 - 96*m.b4*m.b17*m.b38 - 64*m.b4*m.b17*m.b39 - 32*m.b4*m.b17*m.b40 - 256*m.b4
*m.b18*m.b19 - 320*m.b4*m.b18*m.b20 - 288*m.b4*m.b18*m.b21 - 256*m.b4*m.b18*m.b22 - 256*m.b4*
m.b18*m.b23 - 224*m.b4*m.b18*m.b24 - 192*m.b4*m.b18*m.b25 - 160*m.b4*m.b18*m.b26 - 128*m.b4*m.b18
*m.b27 - 128*m.b4*m.b18*m.b28 - 128*m.b4*m.b18*m.b29 - 128*m.b4*m.b18*m.b30 - 128*m.b4*m.b18*
m.b31 - 128*m.b4*m.b18*m.b33 - 128*m.b4*m.b18*m.b34 - 128*m.b4*m.b18*m.b35 - 128*m.b4*m.b18*m.b36
- 128*m.b4*m.b18*m.b37 - 96*m.b4*m.b18*m.b38 - 64*m.b4*m.b18*m.b39 - 32*m.b4*m.b18*m.b40 - 352*
m.b4*m.b19*m.b20 - 320*m.b4*m.b19*m.b21 - 288*m.b4*m.b19*m.b22 - 224*m.b4*m.b19*m.b23 - 192*m.b4*
m.b19*m.b24 - 160*m.b4*m.b19*m.b25 - 128*m.b4*m.b19*m.b26 - 128*m.b4*m.b19*m.b27 - 128*m.b4*m.b19
*m.b28 - 128*m.b4*m.b19*m.b29 - 128*m.b4*m.b19*m.b30 - 128*m.b4*m.b19*m.b31 - 128*m.b4*m.b19*
m.b32 - 128*m.b4*m.b19*m.b33 - 128*m.b4*m.b19*m.b35 - 128*m.b4*m.b19*m.b36 - 128*m.b4*m.b19*m.b37
- 96*m.b4*m.b19*m.b38 - 64*m.b4*m.b19*m.b39 - 32*m.b4*m.b19*m.b40 - 352*m.b4*m.b20*m.b21 - 288*
m.b4*m.b20*m.b22 - 224*m.b4*m.b20*m.b23 - 160*m.b4*m.b20*m.b24 - 128*m.b4*m.b20*m.b25 - 128*m.b4*
m.b20*m.b26 - 128*m.b4*m.b20*m.b27 - 128*m.b4*m.b20*m.b28 - 128*m.b4*m.b20*m.b29 - 128*m.b4*m.b20
*m.b30 - 128*m.b4*m.b20*m.b31 - 128*m.b4*m.b20*m.b32 - 128*m.b4*m.b20*m.b33 - 128*m.b4*m.b20*
m.b34 - 128*m.b4*m.b20*m.b35 - 128*m.b4*m.b20*m.b37 - 96*m.b4*m.b20*m.b38 - 64*m.b4*m.b20*m.b39
- 32*m.b4*m.b20*m.b40 - 288*m.b4*m.b21*m.b22 - 224*m.b4*m.b21*m.b23 - 160*m.b4*m.b21*m.b24 - 128
*m.b4*m.b21*m.b25 - 128*m.b4*m.b21*m.b26 - 128*m.b4*m.b21*m.b27 - 128*m.b4*m.b21*m.b28 - 128*m.b4
*m.b21*m.b29 - 128*m.b4*m.b21*m.b30 - 128*m.b4*m.b21*m.b31 - 128*m.b4*m.b21*m.b32 - 128*m.b4*
m.b21*m.b33 - 128*m.b4*m.b21*m.b34 - 128*m.b4*m.b21*m.b35 - 128*m.b4*m.b21*m.b36 - 128*m.b4*m.b21
*m.b37 - 64*m.b4*m.b21*m.b39 - 32*m.b4*m.b21*m.b40 - 224*m.b4*m.b22*m.b23 - 192*m.b4*m.b22*m.b24
- 160*m.b4*m.b22*m.b25 - 128*m.b4*m.b22*m.b26 - 128*m.b4*m.b22*m.b27 - 128*m.b4*m.b22*m.b28 -
128*m.b4*m.b22*m.b29 - 128*m.b4*m.b22*m.b30 - 128*m.b4*m.b22*m.b31 - 128*m.b4*m.b22*m.b32 - 128*
m.b4*m.b22*m.b33 - 128*m.b4*m.b22*m.b34 - 128*m.b4*m.b22*m.b35 - 128*m.b4*m.b22*m.b36 - 128*m.b4*
m.b22*m.b37 - 96*m.b4*m.b22*m.b38 - 64*m.b4*m.b22*m.b39 - 224*m.b4*m.b23*m.b24 - 192*m.b4*m.b23*
m.b25 - 160*m.b4*m.b23*m.b26 - 128*m.b4*m.b23*m.b27 - 128*m.b4*m.b23*m.b28 - 128*m.b4*m.b23*m.b29
- 128*m.b4*m.b23*m.b30 - 128*m.b4*m.b23*m.b31 - 128*m.b4*m.b23*m.b32 - 128*m.b4*m.b23*m.b33 -
128*m.b4*m.b23*m.b34 - 128*m.b4*m.b23*m.b35 - 128*m.b4*m.b23*m.b36 - 128*m.b4*m.b23*m.b37 - 96*
m.b4*m.b23*m.b38 - 64*m.b4*m.b23*m.b39 - 32*m.b4*m.b23*m.b40 - 224*m.b4*m.b24*m.b25 - 192*m.b4*
m.b24*m.b26 - 160*m.b4*m.b24*m.b27 - 128*m.b4*m.b24*m.b28 - 128*m.b4*m.b24*m.b29 - 128*m.b4*m.b24
*m.b30 - 128*m.b4*m.b24*m.b31 - 128*m.b4*m.b24*m.b32 - 128*m.b4*m.b24*m.b33 - 128*m.b4*m.b24*
m.b34 - 128*m.b4*m.b24*m.b35 - 128*m.b4*m.b24*m.b36 - 128*m.b4*m.b24*m.b37 - 96*m.b4*m.b24*m.b38
- 64*m.b4*m.b24*m.b39 - 32*m.b4*m.b24*m.b40 - 224*m.b4*m.b25*m.b26 - 192*m.b4*m.b25*m.b27 - 160*
m.b4*m.b25*m.b28 - 128*m.b4*m.b25*m.b29 - 128*m.b4*m.b25*m.b30 - 128*m.b4*m.b25*m.b31 - 128*m.b4*
m.b25*m.b32 - 128*m.b4*m.b25*m.b33 - 128*m.b4*m.b25*m.b34 - 128*m.b4*m.b25*m.b35 - 128*m.b4*m.b25
*m.b36 - 128*m.b4*m.b25*m.b37 - 96*m.b4*m.b25*m.b38 - 64*m.b4*m.b25*m.b39 - 32*m.b4*m.b25*m.b40
- 224*m.b4*m.b26*m.b27 - 192*m.b4*m.b26*m.b28 - 160*m.b4*m.b26*m.b29 - 128*m.b4*m.b26*m.b30 -
128*m.b4*m.b26*m.b31 - 128*m.b4*m.b26*m.b32 - 128*m.b4*m.b26*m.b33 - 128*m.b4*m.b26*m.b34 - 128*
m.b4*m.b26*m.b35 - 128*m.b4*m.b26*m.b36 - 128*m.b4*m.b26*m.b37 - 96*m.b4*m.b26*m.b38 - 64*m.b4*
m.b26*m.b39 - 32*m.b4*m.b26*m.b40 - 224*m.b4*m.b27*m.b28 - 192*m.b4*m.b27*m.b29 - 160*m.b4*m.b27*
m.b30 - 128*m.b4*m.b27*m.b31 - 128*m.b4*m.b27*m.b32 - 128*m.b4*m.b27*m.b33 - 128*m.b4*m.b27*m.b34
- 128*m.b4*m.b27*m.b35 - 128*m.b4*m.b27*m.b36 - 128*m.b4*m.b27*m.b37 - 96*m.b4*m.b27*m.b38 - 64*
m.b4*m.b27*m.b39 - 32*m.b4*m.b27*m.b40 - 224*m.b4*m.b28*m.b29 - 192*m.b4*m.b28*m.b30 - 160*m.b4*
m.b28*m.b31 - 128*m.b4*m.b28*m.b32 - 128*m.b4*m.b28*m.b33 - 128*m.b4*m.b28*m.b34 - 128*m.b4*m.b28
*m.b35 - 128*m.b4*m.b28*m.b36 - 128*m.b4*m.b28*m.b37 - 96*m.b4*m.b28*m.b38 - 64*m.b4*m.b28*m.b39
- 32*m.b4*m.b28*m.b40 - 224*m.b4*m.b29*m.b30 - 192*m.b4*m.b29*m.b31 - 160*m.b4*m.b29*m.b32 - 128
*m.b4*m.b29*m.b33 - 128*m.b4*m.b29*m.b34 - 128*m.b4*m.b29*m.b35 - 128*m.b4*m.b29*m.b36 - 128*m.b4
*m.b29*m.b37 - 96*m.b4*m.b29*m.b38 - 64*m.b4*m.b29*m.b39 - 32*m.b4*m.b29*m.b40 - 224*m.b4*m.b30*
m.b31 - 192*m.b4*m.b30*m.b32 - 160*m.b4*m.b30*m.b33 - 128*m.b4*m.b30*m.b34 - 128*m.b4*m.b30*m.b35
- 128*m.b4*m.b30*m.b36 - 128*m.b4*m.b30*m.b37 - 96*m.b4*m.b30*m.b38 - 64*m.b4*m.b30*m.b39 - 32*
m.b4*m.b30*m.b40 - 224*m.b4*m.b31*m.b32 - 192*m.b4*m.b31*m.b33 - 160*m.b4*m.b31*m.b34 - 128*m.b4*
m.b31*m.b35 - 128*m.b4*m.b31*m.b36 - 128*m.b4*m.b31*m.b37 - 96*m.b4*m.b31*m.b38 - 64*m.b4*m.b31*
m.b39 - 32*m.b4*m.b31*m.b40 - 224*m.b4*m.b32*m.b33 - 192*m.b4*m.b32*m.b34 - 160*m.b4*m.b32*m.b35
- 128*m.b4*m.b32*m.b36 - 128*m.b4*m.b32*m.b37 - 96*m.b4*m.b32*m.b38 - 64*m.b4*m.b32*m.b39 - 32*
m.b4*m.b32*m.b40 - 224*m.b4*m.b33*m.b34 - 192*m.b4*m.b33*m.b35 - 160*m.b4*m.b33*m.b36 - 128*m.b4*
m.b33*m.b37 - 96*m.b4*m.b33*m.b38 - 64*m.b4*m.b33*m.b39 - 32*m.b4*m.b33*m.b40 - 224*m.b4*m.b34*
m.b35 - 192*m.b4*m.b34*m.b36 - 160*m.b4*m.b34*m.b37 - 96*m.b4*m.b34*m.b38 - 64*m.b4*m.b34*m.b39
- 32*m.b4*m.b34*m.b40 - 224*m.b4*m.b35*m.b36 - 192*m.b4*m.b35*m.b37 - 128*m.b4*m.b35*m.b38 - 64*
m.b4*m.b35*m.b39 - 32*m.b4*m.b35*m.b40 - 224*m.b4*m.b36*m.b37 - 160*m.b4*m.b36*m.b38 - 96*m.b4*
m.b36*m.b39 - 32*m.b4*m.b36*m.b40 - 192*m.b4*m.b37*m.b38 - 128*m.b4*m.b37*m.b39 - 64*m.b4*m.b37*
m.b40 - 128*m.b4*m.b38*m.b39 - 64*m.b4*m.b38*m.b40 - 64*m.b4*m.b39*m.b40 - 64*m.b5*m.b6*m.b7 - 96
*m.b5*m.b6*m.b8 - 96*m.b5*m.b6*m.b9 - 96*m.b5*m.b6*m.b10 - 64*m.b5*m.b6*m.b11 - 64*m.b5*m.b6*
m.b12 - 64*m.b5*m.b6*m.b13 - 64*m.b5*m.b6*m.b14 - 64*m.b5*m.b6*m.b15 - 64*m.b5*m.b6*m.b16 - 64*
m.b5*m.b6*m.b17 - 64*m.b5*m.b6*m.b18 - 64*m.b5*m.b6*m.b19 - 192*m.b5*m.b6*m.b20 - 320*m.b5*m.b6*
m.b21 - 320*m.b5*m.b6*m.b22 - 320*m.b5*m.b6*m.b23 - 320*m.b5*m.b6*m.b24 - 320*m.b5*m.b6*m.b25 -
320*m.b5*m.b6*m.b26 - 320*m.b5*m.b6*m.b27 - 320*m.b5*m.b6*m.b28 - 320*m.b5*m.b6*m.b29 - 320*m.b5*
m.b6*m.b30 - 320*m.b5*m.b6*m.b31 - 320*m.b5*m.b6*m.b32 - 320*m.b5*m.b6*m.b33 - 320*m.b5*m.b6*
m.b34 - 320*m.b5*m.b6*m.b35 - 288*m.b5*m.b6*m.b36 - 224*m.b5*m.b6*m.b37 - 160*m.b5*m.b6*m.b38 -
96*m.b5*m.b6*m.b39 - 32*m.b5*m.b6*m.b40 - 96*m.b5*m.b7*m.b8 - 64*m.b5*m.b7*m.b9 - 96*m.b5*m.b7*
m.b10 - 96*m.b5*m.b7*m.b11 - 64*m.b5*m.b7*m.b12 - 64*m.b5*m.b7*m.b13 - 64*m.b5*m.b7*m.b14 - 64*
m.b5*m.b7*m.b15 - 64*m.b5*m.b7*m.b16 - 64*m.b5*m.b7*m.b17 - 64*m.b5*m.b7*m.b18 - 192*m.b5*m.b7*
m.b19 - 192*m.b5*m.b7*m.b20 - 320*m.b5*m.b7*m.b21 - 320*m.b5*m.b7*m.b22 - 320*m.b5*m.b7*m.b23 -
320*m.b5*m.b7*m.b24 - 320*m.b5*m.b7*m.b25 - 320*m.b5*m.b7*m.b26 - 320*m.b5*m.b7*m.b27 - 320*m.b5*
m.b7*m.b28 - 320*m.b5*m.b7*m.b29 - 320*m.b5*m.b7*m.b30 - 320*m.b5*m.b7*m.b31 - 320*m.b5*m.b7*
m.b32 - 320*m.b5*m.b7*m.b33 - 320*m.b5*m.b7*m.b34 - 288*m.b5*m.b7*m.b35 - 256*m.b5*m.b7*m.b36 -
192*m.b5*m.b7*m.b37 - 128*m.b5*m.b7*m.b38 - 64*m.b5*m.b7*m.b39 - 32*m.b5*m.b7*m.b40 - 96*m.b5*
m.b8*m.b9 - 96*m.b5*m.b8*m.b10 - 64*m.b5*m.b8*m.b11 - 96*m.b5*m.b8*m.b12 - 64*m.b5*m.b8*m.b13 -
64*m.b5*m.b8*m.b14 - 64*m.b5*m.b8*m.b15 - 64*m.b5*m.b8*m.b16 - 64*m.b5*m.b8*m.b17 - 192*m.b5*m.b8
*m.b18 - 192*m.b5*m.b8*m.b19 - 192*m.b5*m.b8*m.b20 - 320*m.b5*m.b8*m.b21 - 320*m.b5*m.b8*m.b22 -
320*m.b5*m.b8*m.b23 - 320*m.b5*m.b8*m.b24 - 320*m.b5*m.b8*m.b25 - 320*m.b5*m.b8*m.b26 - 320*m.b5*
m.b8*m.b27 - 320*m.b5*m.b8*m.b28 - 320*m.b5*m.b8*m.b29 - 320*m.b5*m.b8*m.b30 - 320*m.b5*m.b8*
m.b31 - 320*m.b5*m.b8*m.b32 - 320*m.b5*m.b8*m.b33 - 288*m.b5*m.b8*m.b34 - 256*m.b5*m.b8*m.b35 -
224*m.b5*m.b8*m.b36 - 160*m.b5*m.b8*m.b37 - 96*m.b5*m.b8*m.b38 - 64*m.b5*m.b8*m.b39 - 32*m.b5*
m.b8*m.b40 - 96*m.b5*m.b9*m.b10 - 96*m.b5*m.b9*m.b11 - 96*m.b5*m.b9*m.b12 - 64*m.b5*m.b9*m.b13 -
64*m.b5*m.b9*m.b14 - 64*m.b5*m.b9*m.b15 - 64*m.b5*m.b9*m.b16 - 192*m.b5*m.b9*m.b17 - 192*m.b5*
m.b9*m.b18 - 192*m.b5*m.b9*m.b19 - 192*m.b5*m.b9*m.b20 - 320*m.b5*m.b9*m.b21 - 320*m.b5*m.b9*
m.b22 - 320*m.b5*m.b9*m.b23 - 320*m.b5*m.b9*m.b24 - 320*m.b5*m.b9*m.b25 - 320*m.b5*m.b9*m.b26 -
320*m.b5*m.b9*m.b27 - 320*m.b5*m.b9*m.b28 - 320*m.b5*m.b9*m.b29 - 320*m.b5*m.b9*m.b30 - 320*m.b5*
m.b9*m.b31 - 320*m.b5*m.b9*m.b32 - 288*m.b5*m.b9*m.b33 - 256*m.b5*m.b9*m.b34 - 224*m.b5*m.b9*
m.b35 - 192*m.b5*m.b9*m.b36 - 128*m.b5*m.b9*m.b37 - 96*m.b5*m.b9*m.b38 - 64*m.b5*m.b9*m.b39 - 32*
m.b5*m.b9*m.b40 - 96*m.b5*m.b10*m.b11 - 96*m.b5*m.b10*m.b12 - 96*m.b5*m.b10*m.b13 - 96*m.b5*m.b10
*m.b14 - 32*m.b5*m.b10*m.b15 - 192*m.b5*m.b10*m.b16 - 192*m.b5*m.b10*m.b17 - 192*m.b5*m.b10*m.b18
- 192*m.b5*m.b10*m.b19 - 192*m.b5*m.b10*m.b20 - 320*m.b5*m.b10*m.b21 - 320*m.b5*m.b10*m.b22 -
320*m.b5*m.b10*m.b23 - 320*m.b5*m.b10*m.b24 - 320*m.b5*m.b10*m.b25 - 320*m.b5*m.b10*m.b26 - 320*
m.b5*m.b10*m.b27 - 320*m.b5*m.b10*m.b28 - 320*m.b5*m.b10*m.b29 - 320*m.b5*m.b10*m.b30 - 320*m.b5*
m.b10*m.b31 - 288*m.b5*m.b10*m.b32 - 256*m.b5*m.b10*m.b33 - 224*m.b5*m.b10*m.b34 - 192*m.b5*m.b10
*m.b35 - 160*m.b5*m.b10*m.b36 - 128*m.b5*m.b10*m.b37 - 96*m.b5*m.b10*m.b38 - 64*m.b5*m.b10*m.b39
- 32*m.b5*m.b10*m.b40 - 96*m.b5*m.b11*m.b12 - 96*m.b5*m.b11*m.b13 - 96*m.b5*m.b11*m.b14 - 224*
m.b5*m.b11*m.b15 - 192*m.b5*m.b11*m.b16 - 160*m.b5*m.b11*m.b17 - 192*m.b5*m.b11*m.b18 - 192*m.b5*
m.b11*m.b19 - 192*m.b5*m.b11*m.b20 - 320*m.b5*m.b11*m.b21 - 320*m.b5*m.b11*m.b22 - 320*m.b5*m.b11
*m.b23 - 320*m.b5*m.b11*m.b24 - 320*m.b5*m.b11*m.b25 - 320*m.b5*m.b11*m.b26 - 320*m.b5*m.b11*
m.b27 - 320*m.b5*m.b11*m.b28 - 320*m.b5*m.b11*m.b29 - 320*m.b5*m.b11*m.b30 - 288*m.b5*m.b11*m.b31
- 256*m.b5*m.b11*m.b32 - 224*m.b5*m.b11*m.b33 - 192*m.b5*m.b11*m.b34 - 160*m.b5*m.b11*m.b35 -
160*m.b5*m.b11*m.b36 - 128*m.b5*m.b11*m.b37 - 96*m.b5*m.b11*m.b38 - 64*m.b5*m.b11*m.b39 - 32*m.b5
*m.b11*m.b40 - 96*m.b5*m.b12*m.b13 - 224*m.b5*m.b12*m.b14 - 224*m.b5*m.b12*m.b15 - 224*m.b5*m.b12
*m.b16 - 192*m.b5*m.b12*m.b17 - 192*m.b5*m.b12*m.b18 - 160*m.b5*m.b12*m.b19 - 192*m.b5*m.b12*
m.b20 - 320*m.b5*m.b12*m.b21 - 320*m.b5*m.b12*m.b22 - 320*m.b5*m.b12*m.b23 - 320*m.b5*m.b12*m.b24
- 320*m.b5*m.b12*m.b25 - 320*m.b5*m.b12*m.b26 - 320*m.b5*m.b12*m.b27 - 320*m.b5*m.b12*m.b28 -
320*m.b5*m.b12*m.b29 - 288*m.b5*m.b12*m.b30 - 256*m.b5*m.b12*m.b31 - 224*m.b5*m.b12*m.b32 - 192*
m.b5*m.b12*m.b33 - 160*m.b5*m.b12*m.b34 - 160*m.b5*m.b12*m.b35 - 160*m.b5*m.b12*m.b36 - 128*m.b5*
m.b12*m.b37 - 96*m.b5*m.b12*m.b38 - 64*m.b5*m.b12*m.b39 - 32*m.b5*m.b12*m.b40 - 224*m.b5*m.b13*
m.b14 - 224*m.b5*m.b13*m.b15 - 224*m.b5*m.b13*m.b16 - 224*m.b5*m.b13*m.b17 - 192*m.b5*m.b13*m.b18
- 192*m.b5*m.b13*m.b19 - 192*m.b5*m.b13*m.b20 - 160*m.b5*m.b13*m.b21 - 320*m.b5*m.b13*m.b22 -
320*m.b5*m.b13*m.b23 - 320*m.b5*m.b13*m.b24 - 320*m.b5*m.b13*m.b25 - 320*m.b5*m.b13*m.b26 - 320*
m.b5*m.b13*m.b27 - 320*m.b5*m.b13*m.b28 - 288*m.b5*m.b13*m.b29 - 256*m.b5*m.b13*m.b30 - 224*m.b5*
m.b13*m.b31 - 192*m.b5*m.b13*m.b32 - 160*m.b5*m.b13*m.b33 - 160*m.b5*m.b13*m.b34 - 160*m.b5*m.b13
*m.b35 - 160*m.b5*m.b13*m.b36 - 128*m.b5*m.b13*m.b37 - 96*m.b5*m.b13*m.b38 - 64*m.b5*m.b13*m.b39
- 32*m.b5*m.b13*m.b40 - 224*m.b5*m.b14*m.b15 - 224*m.b5*m.b14*m.b16 - 224*m.b5*m.b14*m.b17 - 224
*m.b5*m.b14*m.b18 - 192*m.b5*m.b14*m.b19 - 192*m.b5*m.b14*m.b20 - 320*m.b5*m.b14*m.b21 - 320*m.b5
*m.b14*m.b22 - 160*m.b5*m.b14*m.b23 - 320*m.b5*m.b14*m.b24 - 320*m.b5*m.b14*m.b25 - 320*m.b5*
m.b14*m.b26 - 320*m.b5*m.b14*m.b27 - 288*m.b5*m.b14*m.b28 - 256*m.b5*m.b14*m.b29 - 224*m.b5*m.b14
*m.b30 - 192*m.b5*m.b14*m.b31 - 160*m.b5*m.b14*m.b32 - 160*m.b5*m.b14*m.b33 - 160*m.b5*m.b14*
m.b34 - 160*m.b5*m.b14*m.b35 - 160*m.b5*m.b14*m.b36 - 128*m.b5*m.b14*m.b37 - 96*m.b5*m.b14*m.b38
- 64*m.b5*m.b14*m.b39 - 32*m.b5*m.b14*m.b40 - 224*m.b5*m.b15*m.b16 - 224*m.b5*m.b15*m.b17 - 256*
m.b5*m.b15*m.b18 - 224*m.b5*m.b15*m.b19 - 192*m.b5*m.b15*m.b20 - 320*m.b5*m.b15*m.b21 - 320*m.b5*
m.b15*m.b22 - 320*m.b5*m.b15*m.b23 - 320*m.b5*m.b15*m.b24 - 160*m.b5*m.b15*m.b25 - 320*m.b5*m.b15
*m.b26 - 288*m.b5*m.b15*m.b27 - 256*m.b5*m.b15*m.b28 - 224*m.b5*m.b15*m.b29 - 192*m.b5*m.b15*
m.b30 - 160*m.b5*m.b15*m.b31 - 160*m.b5*m.b15*m.b32 - 160*m.b5*m.b15*m.b33 - 160*m.b5*m.b15*m.b34
- 160*m.b5*m.b15*m.b35 - 160*m.b5*m.b15*m.b36 - 128*m.b5*m.b15*m.b37 - 96*m.b5*m.b15*m.b38 - 64*
m.b5*m.b15*m.b39 - 32*m.b5*m.b15*m.b40 - 224*m.b5*m.b16*m.b17 - 224*m.b5*m.b16*m.b18 - 256*m.b5*
m.b16*m.b19 - 224*m.b5*m.b16*m.b20 - 320*m.b5*m.b16*m.b21 - 320*m.b5*m.b16*m.b22 - 320*m.b5*m.b16
*m.b23 - 320*m.b5*m.b16*m.b24 - 320*m.b5*m.b16*m.b25 - 288*m.b5*m.b16*m.b26 - 96*m.b5*m.b16*m.b27
- 224*m.b5*m.b16*m.b28 - 192*m.b5*m.b16*m.b29 - 160*m.b5*m.b16*m.b30 - 160*m.b5*m.b16*m.b31 -
160*m.b5*m.b16*m.b32 - 160*m.b5*m.b16*m.b33 - 160*m.b5*m.b16*m.b34 - 160*m.b5*m.b16*m.b35 - 160*
m.b5*m.b16*m.b36 - 128*m.b5*m.b16*m.b37 - 96*m.b5*m.b16*m.b38 - 64*m.b5*m.b16*m.b39 - 32*m.b5*
m.b16*m.b40 - 224*m.b5*m.b17*m.b18 - 288*m.b5*m.b17*m.b19 - 256*m.b5*m.b17*m.b20 - 352*m.b5*m.b17
*m.b21 - 320*m.b5*m.b17*m.b22 - 320*m.b5*m.b17*m.b23 - 320*m.b5*m.b17*m.b24 - 288*m.b5*m.b17*
m.b25 - 256*m.b5*m.b17*m.b26 - 224*m.b5*m.b17*m.b27 - 192*m.b5*m.b17*m.b28 - 160*m.b5*m.b17*m.b30
- 160*m.b5*m.b17*m.b31 - 160*m.b5*m.b17*m.b32 - 160*m.b5*m.b17*m.b33 - 160*m.b5*m.b17*m.b34 -
160*m.b5*m.b17*m.b35 - 160*m.b5*m.b17*m.b36 - 128*m.b5*m.b17*m.b37 - 96*m.b5*m.b17*m.b38 - 64*
m.b5*m.b17*m.b39 - 32*m.b5*m.b17*m.b40 - 224*m.b5*m.b18*m.b19 - 288*m.b5*m.b18*m.b20 - 384*m.b5*
m.b18*m.b21 - 352*m.b5*m.b18*m.b22 - 320*m.b5*m.b18*m.b23 - 288*m.b5*m.b18*m.b24 - 256*m.b5*m.b18
*m.b25 - 224*m.b5*m.b18*m.b26 - 192*m.b5*m.b18*m.b27 - 160*m.b5*m.b18*m.b28 - 160*m.b5*m.b18*
m.b29 - 160*m.b5*m.b18*m.b30 - 160*m.b5*m.b18*m.b32 - 160*m.b5*m.b18*m.b33 - 160*m.b5*m.b18*m.b34
- 160*m.b5*m.b18*m.b35 - 160*m.b5*m.b18*m.b36 - 128*m.b5*m.b18*m.b37 - 96*m.b5*m.b18*m.b38 - 64*
m.b5*m.b18*m.b39 - 32*m.b5*m.b18*m.b40 - 320*m.b5*m.b19*m.b20 - 416*m.b5*m.b19*m.b21 - 384*m.b5*
m.b19*m.b22 - 320*m.b5*m.b19*m.b23 - 256*m.b5*m.b19*m.b24 - 224*m.b5*m.b19*m.b25 - 192*m.b5*m.b19
*m.b26 - 160*m.b5*m.b19*m.b27 - 160*m.b5*m.b19*m.b28 - 160*m.b5*m.b19*m.b29 - 160*m.b5*m.b19*
m.b30 - 160*m.b5*m.b19*m.b31 - 160*m.b5*m.b19*m.b32 - 160*m.b5*m.b19*m.b34 - 160*m.b5*m.b19*m.b35
- 160*m.b5*m.b19*m.b36 - 128*m.b5*m.b19*m.b37 - 96*m.b5*m.b19*m.b38 - 64*m.b5*m.b19*m.b39 - 32*
m.b5*m.b19*m.b40 - 448*m.b5*m.b20*m.b21 - 384*m.b5*m.b20*m.b22 - 320*m.b5*m.b20*m.b23 - 256*m.b5*
m.b20*m.b24 - 192*m.b5*m.b20*m.b25 - 160*m.b5*m.b20*m.b26 - 160*m.b5*m.b20*m.b27 - 160*m.b5*m.b20
*m.b28 - 160*m.b5*m.b20*m.b29 - 160*m.b5*m.b20*m.b30 - 160*m.b5*m.b20*m.b31 - 160*m.b5*m.b20*
m.b32 - 160*m.b5*m.b20*m.b33 - 160*m.b5*m.b20*m.b34 - 160*m.b5*m.b20*m.b36 - 128*m.b5*m.b20*m.b37
- 96*m.b5*m.b20*m.b38 - 64*m.b5*m.b20*m.b39 - 32*m.b5*m.b20*m.b40 - 384*m.b5*m.b21*m.b22 - 320*
m.b5*m.b21*m.b23 - 256*m.b5*m.b21*m.b24 - 192*m.b5*m.b21*m.b25 - 160*m.b5*m.b21*m.b26 - 160*m.b5*
m.b21*m.b27 - 160*m.b5*m.b21*m.b28 - 160*m.b5*m.b21*m.b29 - 160*m.b5*m.b21*m.b30 - 160*m.b5*m.b21
*m.b31 - 160*m.b5*m.b21*m.b32 - 160*m.b5*m.b21*m.b33 - 160*m.b5*m.b21*m.b34 - 160*m.b5*m.b21*
m.b35 - 160*m.b5*m.b21*m.b36 - 96*m.b5*m.b21*m.b38 - 64*m.b5*m.b21*m.b39 - 32*m.b5*m.b21*m.b40 -
320*m.b5*m.b22*m.b23 - 256*m.b5*m.b22*m.b24 - 224*m.b5*m.b22*m.b25 - 192*m.b5*m.b22*m.b26 - 160*
m.b5*m.b22*m.b27 - 160*m.b5*m.b22*m.b28 - 160*m.b5*m.b22*m.b29 - 160*m.b5*m.b22*m.b30 - 160*m.b5*
m.b22*m.b31 - 160*m.b5*m.b22*m.b32 - 160*m.b5*m.b22*m.b33 - 160*m.b5*m.b22*m.b34 - 160*m.b5*m.b22
*m.b35 - 160*m.b5*m.b22*m.b36 - 128*m.b5*m.b22*m.b37 - 96*m.b5*m.b22*m.b38 - 32*m.b5*m.b22*m.b40
- 288*m.b5*m.b23*m.b24 - 256*m.b5*m.b23*m.b25 - 224*m.b5*m.b23*m.b26 - 192*m.b5*m.b23*m.b27 -
160*m.b5*m.b23*m.b28 - 160*m.b5*m.b23*m.b29 - 160*m.b5*m.b23*m.b30 - 160*m.b5*m.b23*m.b31 - 160*
m.b5*m.b23*m.b32 - 160*m.b5*m.b23*m.b33 - 160*m.b5*m.b23*m.b34 - 160*m.b5*m.b23*m.b35 - 160*m.b5*
m.b23*m.b36 - 128*m.b5*m.b23*m.b37 - 96*m.b5*m.b23*m.b38 - 64*m.b5*m.b23*m.b39 - 32*m.b5*m.b23*
m.b40 - 288*m.b5*m.b24*m.b25 - 256*m.b5*m.b24*m.b26 - 224*m.b5*m.b24*m.b27 - 192*m.b5*m.b24*m.b28
- 160*m.b5*m.b24*m.b29 - 160*m.b5*m.b24*m.b30 - 160*m.b5*m.b24*m.b31 - 160*m.b5*m.b24*m.b32 -
160*m.b5*m.b24*m.b33 - 160*m.b5*m.b24*m.b34 - 160*m.b5*m.b24*m.b35 - 160*m.b5*m.b24*m.b36 - 128*
m.b5*m.b24*m.b37 - 96*m.b5*m.b24*m.b38 - 64*m.b5*m.b24*m.b39 - 32*m.b5*m.b24*m.b40 - 288*m.b5*
m.b25*m.b26 - 256*m.b5*m.b25*m.b27 - 224*m.b5*m.b25*m.b28 - 192*m.b5*m.b25*m.b29 - 160*m.b5*m.b25
*m.b30 - 160*m.b5*m.b25*m.b31 - 160*m.b5*m.b25*m.b32 - 160*m.b5*m.b25*m.b33 - 160*m.b5*m.b25*
m.b34 - 160*m.b5*m.b25*m.b35 - 160*m.b5*m.b25*m.b36 - 128*m.b5*m.b25*m.b37 - 96*m.b5*m.b25*m.b38
- 64*m.b5*m.b25*m.b39 - 32*m.b5*m.b25*m.b40 - 288*m.b5*m.b26*m.b27 - 256*m.b5*m.b26*m.b28 - 224*
m.b5*m.b26*m.b29 - 192*m.b5*m.b26*m.b30 - 160*m.b5*m.b26*m.b31 - 160*m.b5*m.b26*m.b32 - 160*m.b5*
m.b26*m.b33 - 160*m.b5*m.b26*m.b34 - 160*m.b5*m.b26*m.b35 - 160*m.b5*m.b26*m.b36 - 128*m.b5*m.b26
*m.b37 - 96*m.b5*m.b26*m.b38 - 64*m.b5*m.b26*m.b39 - 32*m.b5*m.b26*m.b40 - 288*m.b5*m.b27*m.b28
- 256*m.b5*m.b27*m.b29 - 224*m.b5*m.b27*m.b30 - 192*m.b5*m.b27*m.b31 - 160*m.b5*m.b27*m.b32 -
160*m.b5*m.b27*m.b33 - 160*m.b5*m.b27*m.b34 - 160*m.b5*m.b27*m.b35 - 160*m.b5*m.b27*m.b36 - 128*
m.b5*m.b27*m.b37 - 96*m.b5*m.b27*m.b38 - 64*m.b5*m.b27*m.b39 - 32*m.b5*m.b27*m.b40 - 288*m.b5*
m.b28*m.b29 - 256*m.b5*m.b28*m.b30 - 224*m.b5*m.b28*m.b31 - 192*m.b5*m.b28*m.b32 - 160*m.b5*m.b28
*m.b33 - 160*m.b5*m.b28*m.b34 - 160*m.b5*m.b28*m.b35 - 160*m.b5*m.b28*m.b36 - 128*m.b5*m.b28*
m.b37 - 96*m.b5*m.b28*m.b38 - 64*m.b5*m.b28*m.b39 - 32*m.b5*m.b28*m.b40 - 288*m.b5*m.b29*m.b30 -
256*m.b5*m.b29*m.b31 - 224*m.b5*m.b29*m.b32 - 192*m.b5*m.b29*m.b33 - 160*m.b5*m.b29*m.b34 - 160*
m.b5*m.b29*m.b35 - 160*m.b5*m.b29*m.b36 - 128*m.b5*m.b29*m.b37 - 96*m.b5*m.b29*m.b38 - 64*m.b5*
m.b29*m.b39 - 32*m.b5*m.b29*m.b40 - 288*m.b5*m.b30*m.b31 - 256*m.b5*m.b30*m.b32 - 224*m.b5*m.b30*
m.b33 - 192*m.b5*m.b30*m.b34 - 160*m.b5*m.b30*m.b35 - 160*m.b5*m.b30*m.b36 - 128*m.b5*m.b30*m.b37
- 96*m.b5*m.b30*m.b38 - 64*m.b5*m.b30*m.b39 - 32*m.b5*m.b30*m.b40 - 288*m.b5*m.b31*m.b32 - 256*
m.b5*m.b31*m.b33 - 224*m.b5*m.b31*m.b34 - 192*m.b5*m.b31*m.b35 - 160*m.b5*m.b31*m.b36 - 128*m.b5*
m.b31*m.b37 - 96*m.b5*m.b31*m.b38 - 64*m.b5*m.b31*m.b39 - 32*m.b5*m.b31*m.b40 - 288*m.b5*m.b32*
m.b33 - 256*m.b5*m.b32*m.b34 - 224*m.b5*m.b32*m.b35 - 192*m.b5*m.b32*m.b36 - 128*m.b5*m.b32*m.b37
- 96*m.b5*m.b32*m.b38 - 64*m.b5*m.b32*m.b39 - 32*m.b5*m.b32*m.b40 - 288*m.b5*m.b33*m.b34 - 256*
m.b5*m.b33*m.b35 - 224*m.b5*m.b33*m.b36 - 160*m.b5*m.b33*m.b37 - 96*m.b5*m.b33*m.b38 - 64*m.b5*
m.b33*m.b39 - 32*m.b5*m.b33*m.b40 - 288*m.b5*m.b34*m.b35 - 256*m.b5*m.b34*m.b36 - 192*m.b5*m.b34*
m.b37 - 128*m.b5*m.b34*m.b38 - 64*m.b5*m.b34*m.b39 - 32*m.b5*m.b34*m.b40 - 288*m.b5*m.b35*m.b36
- 224*m.b5*m.b35*m.b37 - 160*m.b5*m.b35*m.b38 - 96*m.b5*m.b35*m.b39 - 32*m.b5*m.b35*m.b40 - 256*
m.b5*m.b36*m.b37 - 192*m.b5*m.b36*m.b38 - 128*m.b5*m.b36*m.b39 - 64*m.b5*m.b36*m.b40 - 192*m.b5*
m.b37*m.b38 - 128*m.b5*m.b37*m.b39 - 64*m.b5*m.b37*m.b40 - 128*m.b5*m.b38*m.b39 - 64*m.b5*m.b38*
m.b40 - 64*m.b5*m.b39*m.b40 - 64*m.b6*m.b7*m.b8 - 96*m.b6*m.b7*m.b9 - 96*m.b6*m.b7*m.b10 - 96*
m.b6*m.b7*m.b11 - 96*m.b6*m.b7*m.b12 - 64*m.b6*m.b7*m.b13 - 64*m.b6*m.b7*m.b14 - 64*m.b6*m.b7*
m.b15 - 64*m.b6*m.b7*m.b16 - 64*m.b6*m.b7*m.b17 - 64*m.b6*m.b7*m.b18 - 64*m.b6*m.b7*m.b19 - 64*
m.b6*m.b7*m.b20 - 224*m.b6*m.b7*m.b21 - 384*m.b6*m.b7*m.b22 - 384*m.b6*m.b7*m.b23 - 384*m.b6*m.b7
*m.b24 - 384*m.b6*m.b7*m.b25 - 384*m.b6*m.b7*m.b26 - 384*m.b6*m.b7*m.b27 - 384*m.b6*m.b7*m.b28 -
384*m.b6*m.b7*m.b29 - 384*m.b6*m.b7*m.b30 - 384*m.b6*m.b7*m.b31 - 384*m.b6*m.b7*m.b32 - 384*m.b6*
m.b7*m.b33 - 384*m.b6*m.b7*m.b34 - 352*m.b6*m.b7*m.b35 - 288*m.b6*m.b7*m.b36 - 224*m.b6*m.b7*
m.b37 - 160*m.b6*m.b7*m.b38 - 96*m.b6*m.b7*m.b39 - 32*m.b6*m.b7*m.b40 - 96*m.b6*m.b8*m.b9 - 64*
m.b6*m.b8*m.b10 - 96*m.b6*m.b8*m.b11 - 96*m.b6*m.b8*m.b12 - 96*m.b6*m.b8*m.b13 - 64*m.b6*m.b8*
m.b14 - 64*m.b6*m.b8*m.b15 - 64*m.b6*m.b8*m.b16 - 64*m.b6*m.b8*m.b17 - 64*m.b6*m.b8*m.b18 - 64*
m.b6*m.b8*m.b19 - 224*m.b6*m.b8*m.b20 - 224*m.b6*m.b8*m.b21 - 384*m.b6*m.b8*m.b22 - 384*m.b6*m.b8
*m.b23 - 384*m.b6*m.b8*m.b24 - 384*m.b6*m.b8*m.b25 - 384*m.b6*m.b8*m.b26 - 384*m.b6*m.b8*m.b27 -
384*m.b6*m.b8*m.b28 - 384*m.b6*m.b8*m.b29 - 384*m.b6*m.b8*m.b30 - 384*m.b6*m.b8*m.b31 - 384*m.b6*
m.b8*m.b32 - 384*m.b6*m.b8*m.b33 - 352*m.b6*m.b8*m.b34 - 320*m.b6*m.b8*m.b35 - 256*m.b6*m.b8*
m.b36 - 192*m.b6*m.b8*m.b37 - 128*m.b6*m.b8*m.b38 - 64*m.b6*m.b8*m.b39 - 32*m.b6*m.b8*m.b40 - 96*
m.b6*m.b9*m.b10 - 96*m.b6*m.b9*m.b11 - 64*m.b6*m.b9*m.b12 - 96*m.b6*m.b9*m.b13 - 96*m.b6*m.b9*
m.b14 - 64*m.b6*m.b9*m.b15 - 64*m.b6*m.b9*m.b16 - 64*m.b6*m.b9*m.b17 - 64*m.b6*m.b9*m.b18 - 224*
m.b6*m.b9*m.b19 - 224*m.b6*m.b9*m.b20 - 224*m.b6*m.b9*m.b21 - 384*m.b6*m.b9*m.b22 - 384*m.b6*m.b9
*m.b23 - 384*m.b6*m.b9*m.b24 - 384*m.b6*m.b9*m.b25 - 384*m.b6*m.b9*m.b26 - 384*m.b6*m.b9*m.b27 -
384*m.b6*m.b9*m.b28 - 384*m.b6*m.b9*m.b29 - 384*m.b6*m.b9*m.b30 - 384*m.b6*m.b9*m.b31 - 384*m.b6*
m.b9*m.b32 - 352*m.b6*m.b9*m.b33 - 320*m.b6*m.b9*m.b34 - 288*m.b6*m.b9*m.b35 - 224*m.b6*m.b9*
m.b36 - 160*m.b6*m.b9*m.b37 - 96*m.b6*m.b9*m.b38 - 64*m.b6*m.b9*m.b39 - 32*m.b6*m.b9*m.b40 - 96*
m.b6*m.b10*m.b11 - 96*m.b6*m.b10*m.b12 - 96*m.b6*m.b10*m.b13 - 64*m.b6*m.b10*m.b14 - 96*m.b6*
m.b10*m.b15 - 64*m.b6*m.b10*m.b16 - 64*m.b6*m.b10*m.b17 - 224*m.b6*m.b10*m.b18 - 224*m.b6*m.b10*
m.b19 - 224*m.b6*m.b10*m.b20 - 224*m.b6*m.b10*m.b21 - 384*m.b6*m.b10*m.b22 - 384*m.b6*m.b10*m.b23
- 384*m.b6*m.b10*m.b24 - 384*m.b6*m.b10*m.b25 - 384*m.b6*m.b10*m.b26 - 384*m.b6*m.b10*m.b27 -
384*m.b6*m.b10*m.b28 - 384*m.b6*m.b10*m.b29 - 384*m.b6*m.b10*m.b30 - 384*m.b6*m.b10*m.b31 - 352*
m.b6*m.b10*m.b32 - 320*m.b6*m.b10*m.b33 - 288*m.b6*m.b10*m.b34 - 256*m.b6*m.b10*m.b35 - 192*m.b6*
m.b10*m.b36 - 128*m.b6*m.b10*m.b37 - 96*m.b6*m.b10*m.b38 - 64*m.b6*m.b10*m.b39 - 32*m.b6*m.b10*
m.b40 - 96*m.b6*m.b11*m.b12 - 96*m.b6*m.b11*m.b13 - 96*m.b6*m.b11*m.b14 - 96*m.b6*m.b11*m.b15 -
64*m.b6*m.b11*m.b16 - 224*m.b6*m.b11*m.b17 - 224*m.b6*m.b11*m.b18 - 224*m.b6*m.b11*m.b19 - 224*
m.b6*m.b11*m.b20 - 224*m.b6*m.b11*m.b21 - 384*m.b6*m.b11*m.b22 - 384*m.b6*m.b11*m.b23 - 384*m.b6*
m.b11*m.b24 - 384*m.b6*m.b11*m.b25 - 384*m.b6*m.b11*m.b26 - 384*m.b6*m.b11*m.b27 - 384*m.b6*m.b11
*m.b28 - 384*m.b6*m.b11*m.b29 - 384*m.b6*m.b11*m.b30 - 352*m.b6*m.b11*m.b31 - 320*m.b6*m.b11*
m.b32 - 288*m.b6*m.b11*m.b33 - 256*m.b6*m.b11*m.b34 - 224*m.b6*m.b11*m.b35 - 160*m.b6*m.b11*m.b36
- 128*m.b6*m.b11*m.b37 - 96*m.b6*m.b11*m.b38 - 64*m.b6*m.b11*m.b39 - 32*m.b6*m.b11*m.b40 - 96*
m.b6*m.b12*m.b13 - 96*m.b6*m.b12*m.b14 - 96*m.b6*m.b12*m.b15 - 256*m.b6*m.b12*m.b16 - 256*m.b6*
m.b12*m.b17 - 192*m.b6*m.b12*m.b18 - 224*m.b6*m.b12*m.b19 - 224*m.b6*m.b12*m.b20 - 224*m.b6*m.b12
*m.b21 - 384*m.b6*m.b12*m.b22 - 384*m.b6*m.b12*m.b23 - 384*m.b6*m.b12*m.b24 - 384*m.b6*m.b12*
m.b25 - 384*m.b6*m.b12*m.b26 - 384*m.b6*m.b12*m.b27 - 384*m.b6*m.b12*m.b28 - 384*m.b6*m.b12*m.b29
- 352*m.b6*m.b12*m.b30 - 320*m.b6*m.b12*m.b31 - 288*m.b6*m.b12*m.b32 - 256*m.b6*m.b12*m.b33 -
224*m.b6*m.b12*m.b34 - 192*m.b6*m.b12*m.b35 - 160*m.b6*m.b12*m.b36 - 128*m.b6*m.b12*m.b37 - 96*
m.b6*m.b12*m.b38 - 64*m.b6*m.b12*m.b39 - 32*m.b6*m.b12*m.b40 - 96*m.b6*m.b13*m.b14 - 256*m.b6*
m.b13*m.b15 - 256*m.b6*m.b13*m.b16 - 256*m.b6*m.b13*m.b17 - 256*m.b6*m.b13*m.b18 - 224*m.b6*m.b13
*m.b19 - 192*m.b6*m.b13*m.b20 - 224*m.b6*m.b13*m.b21 - 384*m.b6*m.b13*m.b22 - 384*m.b6*m.b13*
m.b23 - 384*m.b6*m.b13*m.b24 - 384*m.b6*m.b13*m.b25 - 384*m.b6*m.b13*m.b26 - 384*m.b6*m.b13*m.b27
- 384*m.b6*m.b13*m.b28 - 352*m.b6*m.b13*m.b29 - 320*m.b6*m.b13*m.b30 - 288*m.b6*m.b13*m.b31 -
256*m.b6*m.b13*m.b32 - 224*m.b6*m.b13*m.b33 - 192*m.b6*m.b13*m.b34 - 192*m.b6*m.b13*m.b35 - 160*
m.b6*m.b13*m.b36 - 128*m.b6*m.b13*m.b37 - 96*m.b6*m.b13*m.b38 - 64*m.b6*m.b13*m.b39 - 32*m.b6*
m.b13*m.b40 - 256*m.b6*m.b14*m.b15 - 256*m.b6*m.b14*m.b16 - 256*m.b6*m.b14*m.b17 - 288*m.b6*m.b14
*m.b18 - 256*m.b6*m.b14*m.b19 - 224*m.b6*m.b14*m.b20 - 224*m.b6*m.b14*m.b21 - 192*m.b6*m.b14*
m.b22 - 384*m.b6*m.b14*m.b23 - 384*m.b6*m.b14*m.b24 - 384*m.b6*m.b14*m.b25 - 384*m.b6*m.b14*m.b26
- 384*m.b6*m.b14*m.b27 - 352*m.b6*m.b14*m.b28 - 320*m.b6*m.b14*m.b29 - 288*m.b6*m.b14*m.b30 -
256*m.b6*m.b14*m.b31 - 224*m.b6*m.b14*m.b32 - 192*m.b6*m.b14*m.b33 - 192*m.b6*m.b14*m.b34 - 192*
m.b6*m.b14*m.b35 - 160*m.b6*m.b14*m.b36 - 128*m.b6*m.b14*m.b37 - 96*m.b6*m.b14*m.b38 - 64*m.b6*
m.b14*m.b39 - 32*m.b6*m.b14*m.b40 - 256*m.b6*m.b15*m.b16 - 256*m.b6*m.b15*m.b17 - 256*m.b6*m.b15*
m.b18 - 288*m.b6*m.b15*m.b19 - 256*m.b6*m.b15*m.b20 - 224*m.b6*m.b15*m.b21 - 384*m.b6*m.b15*m.b22
- 384*m.b6*m.b15*m.b23 - 192*m.b6*m.b15*m.b24 - 384*m.b6*m.b15*m.b25 - 384*m.b6*m.b15*m.b26 -
352*m.b6*m.b15*m.b27 - 320*m.b6*m.b15*m.b28 - 288*m.b6*m.b15*m.b29 - 256*m.b6*m.b15*m.b30 - 224*
m.b6*m.b15*m.b31 - 192*m.b6*m.b15*m.b32 - 192*m.b6*m.b15*m.b33 - 192*m.b6*m.b15*m.b34 - 192*m.b6*
m.b15*m.b35 - 160*m.b6*m.b15*m.b36 - 128*m.b6*m.b15*m.b37 - 96*m.b6*m.b15*m.b38 - 64*m.b6*m.b15*
m.b39 - 32*m.b6*m.b15*m.b40 - 256*m.b6*m.b16*m.b17 - 256*m.b6*m.b16*m.b18 - 320*m.b6*m.b16*m.b19
- 288*m.b6*m.b16*m.b20 - 256*m.b6*m.b16*m.b21 - 384*m.b6*m.b16*m.b22 - 384*m.b6*m.b16*m.b23 -
384*m.b6*m.b16*m.b24 - 384*m.b6*m.b16*m.b25 - 160*m.b6*m.b16*m.b26 - 320*m.b6*m.b16*m.b27 - 288*
m.b6*m.b16*m.b28 - 256*m.b6*m.b16*m.b29 - 224*m.b6*m.b16*m.b30 - 192*m.b6*m.b16*m.b31 - 192*m.b6*
m.b16*m.b32 - 192*m.b6*m.b16*m.b33 - 192*m.b6*m.b16*m.b34 - 192*m.b6*m.b16*m.b35 - 160*m.b6*m.b16
*m.b36 - 128*m.b6*m.b16*m.b37 - 96*m.b6*m.b16*m.b38 - 64*m.b6*m.b16*m.b39 - 32*m.b6*m.b16*m.b40
- 256*m.b6*m.b17*m.b18 - 256*m.b6*m.b17*m.b19 - 320*m.b6*m.b17*m.b20 - 288*m.b6*m.b17*m.b21 -
416*m.b6*m.b17*m.b22 - 384*m.b6*m.b17*m.b23 - 384*m.b6*m.b17*m.b24 - 352*m.b6*m.b17*m.b25 - 320*
m.b6*m.b17*m.b26 - 288*m.b6*m.b17*m.b27 - 64*m.b6*m.b17*m.b28 - 224*m.b6*m.b17*m.b29 - 192*m.b6*
m.b17*m.b30 - 192*m.b6*m.b17*m.b31 - 192*m.b6*m.b17*m.b32 - 192*m.b6*m.b17*m.b33 - 192*m.b6*m.b17
*m.b34 - 192*m.b6*m.b17*m.b35 - 160*m.b6*m.b17*m.b36 - 128*m.b6*m.b17*m.b37 - 96*m.b6*m.b17*m.b38
- 64*m.b6*m.b17*m.b39 - 32*m.b6*m.b17*m.b40 - 256*m.b6*m.b18*m.b19 - 352*m.b6*m.b18*m.b20 - 320*
m.b6*m.b18*m.b21 - 448*m.b6*m.b18*m.b22 - 416*m.b6*m.b18*m.b23 - 352*m.b6*m.b18*m.b24 - 320*m.b6*
m.b18*m.b25 - 288*m.b6*m.b18*m.b26 - 256*m.b6*m.b18*m.b27 - 224*m.b6*m.b18*m.b28 - 192*m.b6*m.b18
*m.b29 - 192*m.b6*m.b18*m.b31 - 192*m.b6*m.b18*m.b32 - 192*m.b6*m.b18*m.b33 - 192*m.b6*m.b18*
m.b34 - 192*m.b6*m.b18*m.b35 - 160*m.b6*m.b18*m.b36 - 128*m.b6*m.b18*m.b37 - 96*m.b6*m.b18*m.b38
- 64*m.b6*m.b18*m.b39 - 32*m.b6*m.b18*m.b40 - 256*m.b6*m.b19*m.b20 - 352*m.b6*m.b19*m.b21 - 480*
m.b6*m.b19*m.b22 - 416*m.b6*m.b19*m.b23 - 352*m.b6*m.b19*m.b24 - 288*m.b6*m.b19*m.b25 - 256*m.b6*
m.b19*m.b26 - 224*m.b6*m.b19*m.b27 - 192*m.b6*m.b19*m.b28 - 192*m.b6*m.b19*m.b29 - 192*m.b6*m.b19
*m.b30 - 192*m.b6*m.b19*m.b31 - 192*m.b6*m.b19*m.b33 - 192*m.b6*m.b19*m.b34 - 192*m.b6*m.b19*
m.b35 - 160*m.b6*m.b19*m.b36 - 128*m.b6*m.b19*m.b37 - 96*m.b6*m.b19*m.b38 - 64*m.b6*m.b19*m.b39
- 32*m.b6*m.b19*m.b40 - 384*m.b6*m.b20*m.b21 - 480*m.b6*m.b20*m.b22 - 416*m.b6*m.b20*m.b23 - 352
*m.b6*m.b20*m.b24 - 288*m.b6*m.b20*m.b25 - 224*m.b6*m.b20*m.b26 - 192*m.b6*m.b20*m.b27 - 192*m.b6
*m.b20*m.b28 - 192*m.b6*m.b20*m.b29 - 192*m.b6*m.b20*m.b30 - 192*m.b6*m.b20*m.b31 - 192*m.b6*
m.b20*m.b32 - 192*m.b6*m.b20*m.b33 - 192*m.b6*m.b20*m.b35 - 160*m.b6*m.b20*m.b36 - 128*m.b6*m.b20
*m.b37 - 96*m.b6*m.b20*m.b38 - 64*m.b6*m.b20*m.b39 - 32*m.b6*m.b20*m.b40 - 480*m.b6*m.b21*m.b22
- 416*m.b6*m.b21*m.b23 - 352*m.b6*m.b21*m.b24 - 288*m.b6*m.b21*m.b25 - 224*m.b6*m.b21*m.b26 -
192*m.b6*m.b21*m.b27 - 192*m.b6*m.b21*m.b28 - 192*m.b6*m.b21*m.b29 - 192*m.b6*m.b21*m.b30 - 192*
m.b6*m.b21*m.b31 - 192*m.b6*m.b21*m.b32 - 192*m.b6*m.b21*m.b33 - 192*m.b6*m.b21*m.b34 - 192*m.b6*
m.b21*m.b35 - 128*m.b6*m.b21*m.b37 - 96*m.b6*m.b21*m.b38 - 64*m.b6*m.b21*m.b39 - 32*m.b6*m.b21*
m.b40 - 416*m.b6*m.b22*m.b23 - 352*m.b6*m.b22*m.b24 - 288*m.b6*m.b22*m.b25 - 256*m.b6*m.b22*m.b26
- 224*m.b6*m.b22*m.b27 - 192*m.b6*m.b22*m.b28 - 192*m.b6*m.b22*m.b29 - 192*m.b6*m.b22*m.b30 -
192*m.b6*m.b22*m.b31 - 192*m.b6*m.b22*m.b32 - 192*m.b6*m.b22*m.b33 - 192*m.b6*m.b22*m.b34 - 192*
m.b6*m.b22*m.b35 - 160*m.b6*m.b22*m.b36 - 128*m.b6*m.b22*m.b37 - 64*m.b6*m.b22*m.b39 - 32*m.b6*
m.b22*m.b40 - 352*m.b6*m.b23*m.b24 - 320*m.b6*m.b23*m.b25 - 288*m.b6*m.b23*m.b26 - 256*m.b6*m.b23
*m.b27 - 224*m.b6*m.b23*m.b28 - 192*m.b6*m.b23*m.b29 - 192*m.b6*m.b23*m.b30 - 192*m.b6*m.b23*
m.b31 - 192*m.b6*m.b23*m.b32 - 192*m.b6*m.b23*m.b33 - 192*m.b6*m.b23*m.b34 - 192*m.b6*m.b23*m.b35
- 160*m.b6*m.b23*m.b36 - 128*m.b6*m.b23*m.b37 - 96*m.b6*m.b23*m.b38 - 64*m.b6*m.b23*m.b39 - 352*
m.b6*m.b24*m.b25 - 320*m.b6*m.b24*m.b26 - 288*m.b6*m.b24*m.b27 - 256*m.b6*m.b24*m.b28 - 224*m.b6*
m.b24*m.b29 - 192*m.b6*m.b24*m.b30 - 192*m.b6*m.b24*m.b31 - 192*m.b6*m.b24*m.b32 - 192*m.b6*m.b24
*m.b33 - 192*m.b6*m.b24*m.b34 - 192*m.b6*m.b24*m.b35 - 160*m.b6*m.b24*m.b36 - 128*m.b6*m.b24*
m.b37 - 96*m.b6*m.b24*m.b38 - 64*m.b6*m.b24*m.b39 - 32*m.b6*m.b24*m.b40 - 352*m.b6*m.b25*m.b26 -
320*m.b6*m.b25*m.b27 - 288*m.b6*m.b25*m.b28 - 256*m.b6*m.b25*m.b29 - 224*m.b6*m.b25*m.b30 - 192*
m.b6*m.b25*m.b31 - 192*m.b6*m.b25*m.b32 - 192*m.b6*m.b25*m.b33 - 192*m.b6*m.b25*m.b34 - 192*m.b6*
m.b25*m.b35 - 160*m.b6*m.b25*m.b36 - 128*m.b6*m.b25*m.b37 - 96*m.b6*m.b25*m.b38 - 64*m.b6*m.b25*
m.b39 - 32*m.b6*m.b25*m.b40 - 352*m.b6*m.b26*m.b27 - 320*m.b6*m.b26*m.b28 - 288*m.b6*m.b26*m.b29
- 256*m.b6*m.b26*m.b30 - 224*m.b6*m.b26*m.b31 - 192*m.b6*m.b26*m.b32 - 192*m.b6*m.b26*m.b33 -
192*m.b6*m.b26*m.b34 - 192*m.b6*m.b26*m.b35 - 160*m.b6*m.b26*m.b36 - 128*m.b6*m.b26*m.b37 - 96*
m.b6*m.b26*m.b38 - 64*m.b6*m.b26*m.b39 - 32*m.b6*m.b26*m.b40 - 352*m.b6*m.b27*m.b28 - 320*m.b6*
m.b27*m.b29 - 288*m.b6*m.b27*m.b30 - 256*m.b6*m.b27*m.b31 - 224*m.b6*m.b27*m.b32 - 192*m.b6*m.b27
*m.b33 - 192*m.b6*m.b27*m.b34 - 192*m.b6*m.b27*m.b35 - 160*m.b6*m.b27*m.b36 - 128*m.b6*m.b27*
m.b37 - 96*m.b6*m.b27*m.b38 - 64*m.b6*m.b27*m.b39 - 32*m.b6*m.b27*m.b40 - 352*m.b6*m.b28*m.b29 -
320*m.b6*m.b28*m.b30 - 288*m.b6*m.b28*m.b31 - 256*m.b6*m.b28*m.b32 - 224*m.b6*m.b28*m.b33 - 192*
m.b6*m.b28*m.b34 - 192*m.b6*m.b28*m.b35 - 160*m.b6*m.b28*m.b36 - 128*m.b6*m.b28*m.b37 - 96*m.b6*
m.b28*m.b38 - 64*m.b6*m.b28*m.b39 - 32*m.b6*m.b28*m.b40 - 352*m.b6*m.b29*m.b30 - 320*m.b6*m.b29*
m.b31 - 288*m.b6*m.b29*m.b32 - 256*m.b6*m.b29*m.b33 - 224*m.b6*m.b29*m.b34 - 192*m.b6*m.b29*m.b35
- 160*m.b6*m.b29*m.b36 - 128*m.b6*m.b29*m.b37 - 96*m.b6*m.b29*m.b38 - 64*m.b6*m.b29*m.b39 - 32*
m.b6*m.b29*m.b40 - 352*m.b6*m.b30*m.b31 - 320*m.b6*m.b30*m.b32 - 288*m.b6*m.b30*m.b33 - 256*m.b6*
m.b30*m.b34 - 224*m.b6*m.b30*m.b35 - 160*m.b6*m.b30*m.b36 - 128*m.b6*m.b30*m.b37 - 96*m.b6*m.b30*
m.b38 - 64*m.b6*m.b30*m.b39 - 32*m.b6*m.b30*m.b40 - 352*m.b6*m.b31*m.b32 - 320*m.b6*m.b31*m.b33
- 288*m.b6*m.b31*m.b34 - 256*m.b6*m.b31*m.b35 - 192*m.b6*m.b31*m.b36 - 128*m.b6*m.b31*m.b37 - 96
*m.b6*m.b31*m.b38 - 64*m.b6*m.b31*m.b39 - 32*m.b6*m.b31*m.b40 - 352*m.b6*m.b32*m.b33 - 320*m.b6*
m.b32*m.b34 - 288*m.b6*m.b32*m.b35 - 224*m.b6*m.b32*m.b36 - 160*m.b6*m.b32*m.b37 - 96*m.b6*m.b32*
m.b38 - 64*m.b6*m.b32*m.b39 - 32*m.b6*m.b32*m.b40 - 352*m.b6*m.b33*m.b34 - 320*m.b6*m.b33*m.b35
- 256*m.b6*m.b33*m.b36 - 192*m.b6*m.b33*m.b37 - 128*m.b6*m.b33*m.b38 - 64*m.b6*m.b33*m.b39 - 32*
m.b6*m.b33*m.b40 - 352*m.b6*m.b34*m.b35 - 288*m.b6*m.b34*m.b36 - 224*m.b6*m.b34*m.b37 - 160*m.b6*
m.b34*m.b38 - 96*m.b6*m.b34*m.b39 - 32*m.b6*m.b34*m.b40 - 320*m.b6*m.b35*m.b36 - 256*m.b6*m.b35*
m.b37 - 192*m.b6*m.b35*m.b38 - 128*m.b6*m.b35*m.b39 - 64*m.b6*m.b35*m.b40 - 256*m.b6*m.b36*m.b37
- 192*m.b6*m.b36*m.b38 - 128*m.b6*m.b36*m.b39 - 64*m.b6*m.b36*m.b40 - 192*m.b6*m.b37*m.b38 - 128
*m.b6*m.b37*m.b39 - 64*m.b6*m.b37*m.b40 - 128*m.b6*m.b38*m.b39 - 64*m.b6*m.b38*m.b40 - 64*m.b6*
m.b39*m.b40 - 64*m.b7*m.b8*m.b9 - 96*m.b7*m.b8*m.b10 - 96*m.b7*m.b8*m.b11 - 96*m.b7*m.b8*m.b12 -
96*m.b7*m.b8*m.b13 - 96*m.b7*m.b8*m.b14 - 64*m.b7*m.b8*m.b15 - 64*m.b7*m.b8*m.b16 - 64*m.b7*m.b8*
m.b17 - 64*m.b7*m.b8*m.b18 - 64*m.b7*m.b8*m.b19 - 64*m.b7*m.b8*m.b20 - 64*m.b7*m.b8*m.b21 - 256*
m.b7*m.b8*m.b22 - 448*m.b7*m.b8*m.b23 - 448*m.b7*m.b8*m.b24 - 448*m.b7*m.b8*m.b25 - 448*m.b7*m.b8
*m.b26 - 448*m.b7*m.b8*m.b27 - 448*m.b7*m.b8*m.b28 - 448*m.b7*m.b8*m.b29 - 448*m.b7*m.b8*m.b30 -
448*m.b7*m.b8*m.b31 - 448*m.b7*m.b8*m.b32 - 448*m.b7*m.b8*m.b33 - 416*m.b7*m.b8*m.b34 - 352*m.b7*
m.b8*m.b35 - 288*m.b7*m.b8*m.b36 - 224*m.b7*m.b8*m.b37 - 160*m.b7*m.b8*m.b38 - 96*m.b7*m.b8*m.b39
- 32*m.b7*m.b8*m.b40 - 96*m.b7*m.b9*m.b10 - 64*m.b7*m.b9*m.b11 - 96*m.b7*m.b9*m.b12 - 96*m.b7*
m.b9*m.b13 - 96*m.b7*m.b9*m.b14 - 96*m.b7*m.b9*m.b15 - 64*m.b7*m.b9*m.b16 - 64*m.b7*m.b9*m.b17 -
64*m.b7*m.b9*m.b18 - 64*m.b7*m.b9*m.b19 - 64*m.b7*m.b9*m.b20 - 256*m.b7*m.b9*m.b21 - 256*m.b7*
m.b9*m.b22 - 448*m.b7*m.b9*m.b23 - 448*m.b7*m.b9*m.b24 - 448*m.b7*m.b9*m.b25 - 448*m.b7*m.b9*
m.b26 - 448*m.b7*m.b9*m.b27 - 448*m.b7*m.b9*m.b28 - 448*m.b7*m.b9*m.b29 - 448*m.b7*m.b9*m.b30 -
448*m.b7*m.b9*m.b31 - 448*m.b7*m.b9*m.b32 - 416*m.b7*m.b9*m.b33 - 384*m.b7*m.b9*m.b34 - 320*m.b7*
m.b9*m.b35 - 256*m.b7*m.b9*m.b36 - 192*m.b7*m.b9*m.b37 - 128*m.b7*m.b9*m.b38 - 64*m.b7*m.b9*m.b39
- 32*m.b7*m.b9*m.b40 - 96*m.b7*m.b10*m.b11 - 96*m.b7*m.b10*m.b12 - 64*m.b7*m.b10*m.b13 - 96*m.b7
*m.b10*m.b14 - 96*m.b7*m.b10*m.b15 - 96*m.b7*m.b10*m.b16 - 64*m.b7*m.b10*m.b17 - 64*m.b7*m.b10*
m.b18 - 64*m.b7*m.b10*m.b19 - 256*m.b7*m.b10*m.b20 - 256*m.b7*m.b10*m.b21 - 256*m.b7*m.b10*m.b22
- 448*m.b7*m.b10*m.b23 - 448*m.b7*m.b10*m.b24 - 448*m.b7*m.b10*m.b25 - 448*m.b7*m.b10*m.b26 -
448*m.b7*m.b10*m.b27 - 448*m.b7*m.b10*m.b28 - 448*m.b7*m.b10*m.b29 - 448*m.b7*m.b10*m.b30 - 448*
m.b7*m.b10*m.b31 - 416*m.b7*m.b10*m.b32 - 384*m.b7*m.b10*m.b33 - 352*m.b7*m.b10*m.b34 - 288*m.b7*
m.b10*m.b35 - 224*m.b7*m.b10*m.b36 - 160*m.b7*m.b10*m.b37 - 96*m.b7*m.b10*m.b38 - 64*m.b7*m.b10*
m.b39 - 32*m.b7*m.b10*m.b40 - 96*m.b7*m.b11*m.b12 - 96*m.b7*m.b11*m.b13 - 96*m.b7*m.b11*m.b14 -
64*m.b7*m.b11*m.b15 - 96*m.b7*m.b11*m.b16 - 96*m.b7*m.b11*m.b17 - 64*m.b7*m.b11*m.b18 - 256*m.b7*
m.b11*m.b19 - 256*m.b7*m.b11*m.b20 - 256*m.b7*m.b11*m.b21 - 256*m.b7*m.b11*m.b22 - 448*m.b7*m.b11
*m.b23 - 448*m.b7*m.b11*m.b24 - 448*m.b7*m.b11*m.b25 - 448*m.b7*m.b11*m.b26 - 448*m.b7*m.b11*
m.b27 - 448*m.b7*m.b11*m.b28 - 448*m.b7*m.b11*m.b29 - 448*m.b7*m.b11*m.b30 - 416*m.b7*m.b11*m.b31
- 384*m.b7*m.b11*m.b32 - 352*m.b7*m.b11*m.b33 - 320*m.b7*m.b11*m.b34 - 256*m.b7*m.b11*m.b35 -
192*m.b7*m.b11*m.b36 - 128*m.b7*m.b11*m.b37 - 96*m.b7*m.b11*m.b38 - 64*m.b7*m.b11*m.b39 - 32*m.b7
*m.b11*m.b40 - 96*m.b7*m.b12*m.b13 - 96*m.b7*m.b12*m.b14 - 96*m.b7*m.b12*m.b15 - 96*m.b7*m.b12*
m.b16 - 64*m.b7*m.b12*m.b17 - 288*m.b7*m.b12*m.b18 - 256*m.b7*m.b12*m.b19 - 256*m.b7*m.b12*m.b20
- 256*m.b7*m.b12*m.b21 - 256*m.b7*m.b12*m.b22 - 448*m.b7*m.b12*m.b23 - 448*m.b7*m.b12*m.b24 -
448*m.b7*m.b12*m.b25 - 448*m.b7*m.b12*m.b26 - 448*m.b7*m.b12*m.b27 - 448*m.b7*m.b12*m.b28 - 448*
m.b7*m.b12*m.b29 - 416*m.b7*m.b12*m.b30 - 384*m.b7*m.b12*m.b31 - 352*m.b7*m.b12*m.b32 - 320*m.b7*
m.b12*m.b33 - 288*m.b7*m.b12*m.b34 - 224*m.b7*m.b12*m.b35 - 160*m.b7*m.b12*m.b36 - 128*m.b7*m.b12
*m.b37 - 96*m.b7*m.b12*m.b38 - 64*m.b7*m.b12*m.b39 - 32*m.b7*m.b12*m.b40 - 96*m.b7*m.b13*m.b14 -
96*m.b7*m.b13*m.b15 - 96*m.b7*m.b13*m.b16 - 288*m.b7*m.b13*m.b17 - 320*m.b7*m.b13*m.b18 - 256*
m.b7*m.b13*m.b19 - 256*m.b7*m.b13*m.b20 - 256*m.b7*m.b13*m.b21 - 256*m.b7*m.b13*m.b22 - 448*m.b7*
m.b13*m.b23 - 448*m.b7*m.b13*m.b24 - 448*m.b7*m.b13*m.b25 - 448*m.b7*m.b13*m.b26 - 448*m.b7*m.b13
*m.b27 - 448*m.b7*m.b13*m.b28 - 416*m.b7*m.b13*m.b29 - 384*m.b7*m.b13*m.b30 - 352*m.b7*m.b13*
m.b31 - 320*m.b7*m.b13*m.b32 - 288*m.b7*m.b13*m.b33 - 256*m.b7*m.b13*m.b34 - 192*m.b7*m.b13*m.b35
- 160*m.b7*m.b13*m.b36 - 128*m.b7*m.b13*m.b37 - 96*m.b7*m.b13*m.b38 - 64*m.b7*m.b13*m.b39 - 32*
m.b7*m.b13*m.b40 - 96*m.b7*m.b14*m.b15 - 288*m.b7*m.b14*m.b16 - 288*m.b7*m.b14*m.b17 - 288*m.b7*
m.b14*m.b18 - 320*m.b7*m.b14*m.b19 - 288*m.b7*m.b14*m.b20 - 224*m.b7*m.b14*m.b21 - 256*m.b7*m.b14
*m.b22 - 448*m.b7*m.b14*m.b23 - 448*m.b7*m.b14*m.b24 - 448*m.b7*m.b14*m.b25 - 448*m.b7*m.b14*
m.b26 - 448*m.b7*m.b14*m.b27 - 416*m.b7*m.b14*m.b28 - 384*m.b7*m.b14*m.b29 - 352*m.b7*m.b14*m.b30
- 320*m.b7*m.b14*m.b31 - 288*m.b7*m.b14*m.b32 - 256*m.b7*m.b14*m.b33 - 224*m.b7*m.b14*m.b34 -
192*m.b7*m.b14*m.b35 - 160*m.b7*m.b14*m.b36 - 128*m.b7*m.b14*m.b37 - 96*m.b7*m.b14*m.b38 - 64*
m.b7*m.b14*m.b39 - 32*m.b7*m.b14*m.b40 - 288*m.b7*m.b15*m.b16 - 288*m.b7*m.b15*m.b17 - 288*m.b7*
m.b15*m.b18 - 352*m.b7*m.b15*m.b19 - 320*m.b7*m.b15*m.b20 - 288*m.b7*m.b15*m.b21 - 256*m.b7*m.b15
*m.b22 - 224*m.b7*m.b15*m.b23 - 448*m.b7*m.b15*m.b24 - 448*m.b7*m.b15*m.b25 - 448*m.b7*m.b15*
m.b26 - 416*m.b7*m.b15*m.b27 - 384*m.b7*m.b15*m.b28 - 352*m.b7*m.b15*m.b29 - 320*m.b7*m.b15*m.b30
- 288*m.b7*m.b15*m.b31 - 256*m.b7*m.b15*m.b32 - 224*m.b7*m.b15*m.b33 - 224*m.b7*m.b15*m.b34 -
192*m.b7*m.b15*m.b35 - 160*m.b7*m.b15*m.b36 - 128*m.b7*m.b15*m.b37 - 96*m.b7*m.b15*m.b38 - 64*
m.b7*m.b15*m.b39 - 32*m.b7*m.b15*m.b40 - 288*m.b7*m.b16*m.b17 - 288*m.b7*m.b16*m.b18 - 288*m.b7*
m.b16*m.b19 - 352*m.b7*m.b16*m.b20 - 320*m.b7*m.b16*m.b21 - 288*m.b7*m.b16*m.b22 - 448*m.b7*m.b16
*m.b23 - 448*m.b7*m.b16*m.b24 - 224*m.b7*m.b16*m.b25 - 416*m.b7*m.b16*m.b26 - 384*m.b7*m.b16*
m.b27 - 352*m.b7*m.b16*m.b28 - 320*m.b7*m.b16*m.b29 - 288*m.b7*m.b16*m.b30 - 256*m.b7*m.b16*m.b31
- 224*m.b7*m.b16*m.b32 - 224*m.b7*m.b16*m.b33 - 224*m.b7*m.b16*m.b34 - 192*m.b7*m.b16*m.b35 -
160*m.b7*m.b16*m.b36 - 128*m.b7*m.b16*m.b37 - 96*m.b7*m.b16*m.b38 - 64*m.b7*m.b16*m.b39 - 32*m.b7
*m.b16*m.b40 - 288*m.b7*m.b17*m.b18 - 288*m.b7*m.b17*m.b19 - 384*m.b7*m.b17*m.b20 - 352*m.b7*
m.b17*m.b21 - 320*m.b7*m.b17*m.b22 - 480*m.b7*m.b17*m.b23 - 448*m.b7*m.b17*m.b24 - 416*m.b7*m.b17
*m.b25 - 384*m.b7*m.b17*m.b26 - 128*m.b7*m.b17*m.b27 - 320*m.b7*m.b17*m.b28 - 288*m.b7*m.b17*
m.b29 - 256*m.b7*m.b17*m.b30 - 224*m.b7*m.b17*m.b31 - 224*m.b7*m.b17*m.b32 - 224*m.b7*m.b17*m.b33
- 224*m.b7*m.b17*m.b34 - 192*m.b7*m.b17*m.b35 - 160*m.b7*m.b17*m.b36 - 128*m.b7*m.b17*m.b37 - 96
*m.b7*m.b17*m.b38 - 64*m.b7*m.b17*m.b39 - 32*m.b7*m.b17*m.b40 - 288*m.b7*m.b18*m.b19 - 288*m.b7*
m.b18*m.b20 - 384*m.b7*m.b18*m.b21 - 352*m.b7*m.b18*m.b22 - 512*m.b7*m.b18*m.b23 - 448*m.b7*m.b18
*m.b24 - 384*m.b7*m.b18*m.b25 - 352*m.b7*m.b18*m.b26 - 320*m.b7*m.b18*m.b27 - 288*m.b7*m.b18*
m.b28 - 32*m.b7*m.b18*m.b29 - 224*m.b7*m.b18*m.b30 - 224*m.b7*m.b18*m.b31 - 224*m.b7*m.b18*m.b32
- 224*m.b7*m.b18*m.b33 - 224*m.b7*m.b18*m.b34 - 192*m.b7*m.b18*m.b35 - 160*m.b7*m.b18*m.b36 -
128*m.b7*m.b18*m.b37 - 96*m.b7*m.b18*m.b38 - 64*m.b7*m.b18*m.b39 - 32*m.b7*m.b18*m.b40 - 288*m.b7
*m.b19*m.b20 - 416*m.b7*m.b19*m.b21 - 384*m.b7*m.b19*m.b22 - 512*m.b7*m.b19*m.b23 - 448*m.b7*
m.b19*m.b24 - 384*m.b7*m.b19*m.b25 - 320*m.b7*m.b19*m.b26 - 288*m.b7*m.b19*m.b27 - 256*m.b7*m.b19
*m.b28 - 224*m.b7*m.b19*m.b29 - 224*m.b7*m.b19*m.b30 - 224*m.b7*m.b19*m.b32 - 224*m.b7*m.b19*
m.b33 - 224*m.b7*m.b19*m.b34 - 192*m.b7*m.b19*m.b35 - 160*m.b7*m.b19*m.b36 - 128*m.b7*m.b19*m.b37
- 96*m.b7*m.b19*m.b38 - 64*m.b7*m.b19*m.b39 - 32*m.b7*m.b19*m.b40 - 288*m.b7*m.b20*m.b21 - 384*
m.b7*m.b20*m.b22 - 512*m.b7*m.b20*m.b23 - 448*m.b7*m.b20*m.b24 - 384*m.b7*m.b20*m.b25 - 320*m.b7*
m.b20*m.b26 - 256*m.b7*m.b20*m.b27 - 224*m.b7*m.b20*m.b28 - 224*m.b7*m.b20*m.b29 - 224*m.b7*m.b20
*m.b30 - 224*m.b7*m.b20*m.b31 - 224*m.b7*m.b20*m.b32 - 224*m.b7*m.b20*m.b34 - 192*m.b7*m.b20*
m.b35 - 160*m.b7*m.b20*m.b36 - 128*m.b7*m.b20*m.b37 - 96*m.b7*m.b20*m.b38 - 64*m.b7*m.b20*m.b39
- 32*m.b7*m.b20*m.b40 - 384*m.b7*m.b21*m.b22 - 512*m.b7*m.b21*m.b23 - 448*m.b7*m.b21*m.b24 - 384
*m.b7*m.b21*m.b25 - 320*m.b7*m.b21*m.b26 - 256*m.b7*m.b21*m.b27 - 224*m.b7*m.b21*m.b28 - 224*m.b7
*m.b21*m.b29 - 224*m.b7*m.b21*m.b30 - 224*m.b7*m.b21*m.b31 - 224*m.b7*m.b21*m.b32 - 224*m.b7*
m.b21*m.b33 - 224*m.b7*m.b21*m.b34 - 160*m.b7*m.b21*m.b36 - 128*m.b7*m.b21*m.b37 - 96*m.b7*m.b21*
m.b38 - 64*m.b7*m.b21*m.b39 - 32*m.b7*m.b21*m.b40 - 512*m.b7*m.b22*m.b23 - 448*m.b7*m.b22*m.b24
- 384*m.b7*m.b22*m.b25 - 320*m.b7*m.b22*m.b26 - 288*m.b7*m.b22*m.b27 - 256*m.b7*m.b22*m.b28 -
224*m.b7*m.b22*m.b29 - 224*m.b7*m.b22*m.b30 - 224*m.b7*m.b22*m.b31 - 224*m.b7*m.b22*m.b32 - 224*
m.b7*m.b22*m.b33 - 224*m.b7*m.b22*m.b34 - 192*m.b7*m.b22*m.b35 - 160*m.b7*m.b22*m.b36 - 96*m.b7*
m.b22*m.b38 - 64*m.b7*m.b22*m.b39 - 32*m.b7*m.b22*m.b40 - 448*m.b7*m.b23*m.b24 - 384*m.b7*m.b23*
m.b25 - 352*m.b7*m.b23*m.b26 - 320*m.b7*m.b23*m.b27 - 288*m.b7*m.b23*m.b28 - 256*m.b7*m.b23*m.b29
- 224*m.b7*m.b23*m.b30 - 224*m.b7*m.b23*m.b31 - 224*m.b7*m.b23*m.b32 - 224*m.b7*m.b23*m.b33 -
224*m.b7*m.b23*m.b34 - 192*m.b7*m.b23*m.b35 - 160*m.b7*m.b23*m.b36 - 128*m.b7*m.b23*m.b37 - 96*
m.b7*m.b23*m.b38 - 32*m.b7*m.b23*m.b40 - 416*m.b7*m.b24*m.b25 - 384*m.b7*m.b24*m.b26 - 352*m.b7*
m.b24*m.b27 - 320*m.b7*m.b24*m.b28 - 288*m.b7*m.b24*m.b29 - 256*m.b7*m.b24*m.b30 - 224*m.b7*m.b24
*m.b31 - 224*m.b7*m.b24*m.b32 - 224*m.b7*m.b24*m.b33 - 224*m.b7*m.b24*m.b34 - 192*m.b7*m.b24*
m.b35 - 160*m.b7*m.b24*m.b36 - 128*m.b7*m.b24*m.b37 - 96*m.b7*m.b24*m.b38 - 64*m.b7*m.b24*m.b39
- 32*m.b7*m.b24*m.b40 - 416*m.b7*m.b25*m.b26 - 384*m.b7*m.b25*m.b27 - 352*m.b7*m.b25*m.b28 - 320
*m.b7*m.b25*m.b29 - 288*m.b7*m.b25*m.b30 - 256*m.b7*m.b25*m.b31 - 224*m.b7*m.b25*m.b32 - 224*m.b7
*m.b25*m.b33 - 224*m.b7*m.b25*m.b34 - 192*m.b7*m.b25*m.b35 - 160*m.b7*m.b25*m.b36 - 128*m.b7*
m.b25*m.b37 - 96*m.b7*m.b25*m.b38 - 64*m.b7*m.b25*m.b39 - 32*m.b7*m.b25*m.b40 - 416*m.b7*m.b26*
m.b27 - 384*m.b7*m.b26*m.b28 - 352*m.b7*m.b26*m.b29 - 320*m.b7*m.b26*m.b30 - 288*m.b7*m.b26*m.b31
- 256*m.b7*m.b26*m.b32 - 224*m.b7*m.b26*m.b33 - 224*m.b7*m.b26*m.b34 - 192*m.b7*m.b26*m.b35 -
160*m.b7*m.b26*m.b36 - 128*m.b7*m.b26*m.b37 - 96*m.b7*m.b26*m.b38 - 64*m.b7*m.b26*m.b39 - 32*m.b7
*m.b26*m.b40 - 416*m.b7*m.b27*m.b28 - 384*m.b7*m.b27*m.b29 - 352*m.b7*m.b27*m.b30 - 320*m.b7*
m.b27*m.b31 - 288*m.b7*m.b27*m.b32 - 256*m.b7*m.b27*m.b33 - 224*m.b7*m.b27*m.b34 - 192*m.b7*m.b27
*m.b35 - 160*m.b7*m.b27*m.b36 - 128*m.b7*m.b27*m.b37 - 96*m.b7*m.b27*m.b38 - 64*m.b7*m.b27*m.b39
- 32*m.b7*m.b27*m.b40 - 416*m.b7*m.b28*m.b29 - 384*m.b7*m.b28*m.b30 - 352*m.b7*m.b28*m.b31 - 320
*m.b7*m.b28*m.b32 - 288*m.b7*m.b28*m.b33 - 256*m.b7*m.b28*m.b34 - 192*m.b7*m.b28*m.b35 - 160*m.b7
*m.b28*m.b36 - 128*m.b7*m.b28*m.b37 - 96*m.b7*m.b28*m.b38 - 64*m.b7*m.b28*m.b39 - 32*m.b7*m.b28*
m.b40 - 416*m.b7*m.b29*m.b30 - 384*m.b7*m.b29*m.b31 - 352*m.b7*m.b29*m.b32 - 320*m.b7*m.b29*m.b33
- 288*m.b7*m.b29*m.b34 - 224*m.b7*m.b29*m.b35 - 160*m.b7*m.b29*m.b36 - 128*m.b7*m.b29*m.b37 - 96
*m.b7*m.b29*m.b38 - 64*m.b7*m.b29*m.b39 - 32*m.b7*m.b29*m.b40 - 416*m.b7*m.b30*m.b31 - 384*m.b7*
m.b30*m.b32 - 352*m.b7*m.b30*m.b33 - 320*m.b7*m.b30*m.b34 - 256*m.b7*m.b30*m.b35 - 192*m.b7*m.b30
*m.b36 - 128*m.b7*m.b30*m.b37 - 96*m.b7*m.b30*m.b38 - 64*m.b7*m.b30*m.b39 - 32*m.b7*m.b30*m.b40
- 416*m.b7*m.b31*m.b32 - 384*m.b7*m.b31*m.b33 - 352*m.b7*m.b31*m.b34 - 288*m.b7*m.b31*m.b35 -
224*m.b7*m.b31*m.b36 - 160*m.b7*m.b31*m.b37 - 96*m.b7*m.b31*m.b38 - 64*m.b7*m.b31*m.b39 - 32*m.b7
*m.b31*m.b40 - 416*m.b7*m.b32*m.b33 - 384*m.b7*m.b32*m.b34 - 320*m.b7*m.b32*m.b35 - 256*m.b7*
m.b32*m.b36 - 192*m.b7*m.b32*m.b37 - 128*m.b7*m.b32*m.b38 - 64*m.b7*m.b32*m.b39 - 32*m.b7*m.b32*
m.b40 - 416*m.b7*m.b33*m.b34 - 352*m.b7*m.b33*m.b35 - 288*m.b7*m.b33*m.b36 - 224*m.b7*m.b33*m.b37
- 160*m.b7*m.b33*m.b38 - 96*m.b7*m.b33*m.b39 - 32*m.b7*m.b33*m.b40 - 384*m.b7*m.b34*m.b35 - 320*
m.b7*m.b34*m.b36 - 256*m.b7*m.b34*m.b37 - 192*m.b7*m.b34*m.b38 - 128*m.b7*m.b34*m.b39 - 64*m.b7*
m.b34*m.b40 - 320*m.b7*m.b35*m.b36 - 256*m.b7*m.b35*m.b37 - 192*m.b7*m.b35*m.b38 - 128*m.b7*m.b35
*m.b39 - 64*m.b7*m.b35*m.b40 - 256*m.b7*m.b36*m.b37 - 192*m.b7*m.b36*m.b38 - 128*m.b7*m.b36*m.b39
- 64*m.b7*m.b36*m.b40 - 192*m.b7*m.b37*m.b38 - 128*m.b7*m.b37*m.b39 - 64*m.b7*m.b37*m.b40 - 128*
m.b7*m.b38*m.b39 - 64*m.b7*m.b38*m.b40 - 64*m.b7*m.b39*m.b40 - 64*m.b8*m.b9*m.b10 - 96*m.b8*m.b9*
m.b11 - 96*m.b8*m.b9*m.b12 - 96*m.b8*m.b9*m.b13 - 96*m.b8*m.b9*m.b14 - 96*m.b8*m.b9*m.b15 - 96*
m.b8*m.b9*m.b16 - 64*m.b8*m.b9*m.b17 - 64*m.b8*m.b9*m.b18 - 64*m.b8*m.b9*m.b19 - 64*m.b8*m.b9*
m.b20 - 64*m.b8*m.b9*m.b21 - 64*m.b8*m.b9*m.b22 - 288*m.b8*m.b9*m.b23 - 512*m.b8*m.b9*m.b24 - 512
*m.b8*m.b9*m.b25 - 512*m.b8*m.b9*m.b26 - 512*m.b8*m.b9*m.b27 - 512*m.b8*m.b9*m.b28 - 512*m.b8*
m.b9*m.b29 - 512*m.b8*m.b9*m.b30 - 512*m.b8*m.b9*m.b31 - 512*m.b8*m.b9*m.b32 - 480*m.b8*m.b9*
m.b33 - 416*m.b8*m.b9*m.b34 - 352*m.b8*m.b9*m.b35 - 288*m.b8*m.b9*m.b36 - 224*m.b8*m.b9*m.b37 -
160*m.b8*m.b9*m.b38 - 96*m.b8*m.b9*m.b39 - 32*m.b8*m.b9*m.b40 - 96*m.b8*m.b10*m.b11 - 64*m.b8*
m.b10*m.b12 - 96*m.b8*m.b10*m.b13 - 96*m.b8*m.b10*m.b14 - 96*m.b8*m.b10*m.b15 - 96*m.b8*m.b10*
m.b16 - 96*m.b8*m.b10*m.b17 - 64*m.b8*m.b10*m.b18 - 64*m.b8*m.b10*m.b19 - 64*m.b8*m.b10*m.b20 -
64*m.b8*m.b10*m.b21 - 288*m.b8*m.b10*m.b22 - 288*m.b8*m.b10*m.b23 - 512*m.b8*m.b10*m.b24 - 512*
m.b8*m.b10*m.b25 - 512*m.b8*m.b10*m.b26 - 512*m.b8*m.b10*m.b27 - 512*m.b8*m.b10*m.b28 - 512*m.b8*
m.b10*m.b29 - 512*m.b8*m.b10*m.b30 - 512*m.b8*m.b10*m.b31 - 480*m.b8*m.b10*m.b32 - 448*m.b8*m.b10
*m.b33 - 384*m.b8*m.b10*m.b34 - 320*m.b8*m.b10*m.b35 - 256*m.b8*m.b10*m.b36 - 192*m.b8*m.b10*
m.b37 - 128*m.b8*m.b10*m.b38 - 64*m.b8*m.b10*m.b39 - 32*m.b8*m.b10*m.b40 - 96*m.b8*m.b11*m.b12 -
96*m.b8*m.b11*m.b13 - 64*m.b8*m.b11*m.b14 - 96*m.b8*m.b11*m.b15 - 96*m.b8*m.b11*m.b16 - 96*m.b8*
m.b11*m.b17 - 96*m.b8*m.b11*m.b18 - 64*m.b8*m.b11*m.b19 - 64*m.b8*m.b11*m.b20 - 288*m.b8*m.b11*
m.b21 - 288*m.b8*m.b11*m.b22 - 288*m.b8*m.b11*m.b23 - 512*m.b8*m.b11*m.b24 - 512*m.b8*m.b11*m.b25
- 512*m.b8*m.b11*m.b26 - 512*m.b8*m.b11*m.b27 - 512*m.b8*m.b11*m.b28 - 512*m.b8*m.b11*m.b29 -
512*m.b8*m.b11*m.b30 - 480*m.b8*m.b11*m.b31 - 448*m.b8*m.b11*m.b32 - 416*m.b8*m.b11*m.b33 - 352*
m.b8*m.b11*m.b34 - 288*m.b8*m.b11*m.b35 - 224*m.b8*m.b11*m.b36 - 160*m.b8*m.b11*m.b37 - 96*m.b8*
m.b11*m.b38 - 64*m.b8*m.b11*m.b39 - 32*m.b8*m.b11*m.b40 - 96*m.b8*m.b12*m.b13 - 96*m.b8*m.b12*
m.b14 - 96*m.b8*m.b12*m.b15 - 64*m.b8*m.b12*m.b16 - 96*m.b8*m.b12*m.b17 - 128*m.b8*m.b12*m.b18 -
96*m.b8*m.b12*m.b19 - 288*m.b8*m.b12*m.b20 - 288*m.b8*m.b12*m.b21 - 288*m.b8*m.b12*m.b22 - 288*
m.b8*m.b12*m.b23 - 512*m.b8*m.b12*m.b24 - 512*m.b8*m.b12*m.b25 - 512*m.b8*m.b12*m.b26 - 512*m.b8*
m.b12*m.b27 - 512*m.b8*m.b12*m.b28 - 512*m.b8*m.b12*m.b29 - 480*m.b8*m.b12*m.b30 - 448*m.b8*m.b12
*m.b31 - 416*m.b8*m.b12*m.b32 - 384*m.b8*m.b12*m.b33 - 320*m.b8*m.b12*m.b34 - 256*m.b8*m.b12*
m.b35 - 192*m.b8*m.b12*m.b36 - 128*m.b8*m.b12*m.b37 - 96*m.b8*m.b12*m.b38 - 64*m.b8*m.b12*m.b39
- 32*m.b8*m.b12*m.b40 - 96*m.b8*m.b13*m.b14 - 96*m.b8*m.b13*m.b15 - 96*m.b8*m.b13*m.b16 - 96*
m.b8*m.b13*m.b17 - 64*m.b8*m.b13*m.b18 - 352*m.b8*m.b13*m.b19 - 320*m.b8*m.b13*m.b20 - 288*m.b8*
m.b13*m.b21 - 288*m.b8*m.b13*m.b22 - 288*m.b8*m.b13*m.b23 - 512*m.b8*m.b13*m.b24 - 512*m.b8*m.b13
*m.b25 - 512*m.b8*m.b13*m.b26 - 512*m.b8*m.b13*m.b27 - 512*m.b8*m.b13*m.b28 - 480*m.b8*m.b13*
m.b29 - 448*m.b8*m.b13*m.b30 - 416*m.b8*m.b13*m.b31 - 384*m.b8*m.b13*m.b32 - 352*m.b8*m.b13*m.b33
- 288*m.b8*m.b13*m.b34 - 224*m.b8*m.b13*m.b35 - 160*m.b8*m.b13*m.b36 - 128*m.b8*m.b13*m.b37 - 96
*m.b8*m.b13*m.b38 - 64*m.b8*m.b13*m.b39 - 32*m.b8*m.b13*m.b40 - 96*m.b8*m.b14*m.b15 - 96*m.b8*
m.b14*m.b16 - 96*m.b8*m.b14*m.b17 - 320*m.b8*m.b14*m.b18 - 384*m.b8*m.b14*m.b19 - 320*m.b8*m.b14*
m.b20 - 320*m.b8*m.b14*m.b21 - 288*m.b8*m.b14*m.b22 - 288*m.b8*m.b14*m.b23 - 512*m.b8*m.b14*m.b24
- 512*m.b8*m.b14*m.b25 - 512*m.b8*m.b14*m.b26 - 512*m.b8*m.b14*m.b27 - 480*m.b8*m.b14*m.b28 -
448*m.b8*m.b14*m.b29 - 416*m.b8*m.b14*m.b30 - 384*m.b8*m.b14*m.b31 - 352*m.b8*m.b14*m.b32 - 320*
m.b8*m.b14*m.b33 - 256*m.b8*m.b14*m.b34 - 192*m.b8*m.b14*m.b35 - 160*m.b8*m.b14*m.b36 - 128*m.b8*
m.b14*m.b37 - 96*m.b8*m.b14*m.b38 - 64*m.b8*m.b14*m.b39 - 32*m.b8*m.b14*m.b40 - 96*m.b8*m.b15*
m.b16 - 320*m.b8*m.b15*m.b17 - 320*m.b8*m.b15*m.b18 - 320*m.b8*m.b15*m.b19 - 384*m.b8*m.b15*m.b20
- 352*m.b8*m.b15*m.b21 - 288*m.b8*m.b15*m.b22 - 288*m.b8*m.b15*m.b23 - 512*m.b8*m.b15*m.b24 -
512*m.b8*m.b15*m.b25 - 512*m.b8*m.b15*m.b26 - 480*m.b8*m.b15*m.b27 - 448*m.b8*m.b15*m.b28 - 416*
m.b8*m.b15*m.b29 - 384*m.b8*m.b15*m.b30 - 352*m.b8*m.b15*m.b31 - 320*m.b8*m.b15*m.b32 - 288*m.b8*
m.b15*m.b33 - 224*m.b8*m.b15*m.b34 - 192*m.b8*m.b15*m.b35 - 160*m.b8*m.b15*m.b36 - 128*m.b8*m.b15
*m.b37 - 96*m.b8*m.b15*m.b38 - 64*m.b8*m.b15*m.b39 - 32*m.b8*m.b15*m.b40 - 320*m.b8*m.b16*m.b17
- 320*m.b8*m.b16*m.b18 - 320*m.b8*m.b16*m.b19 - 416*m.b8*m.b16*m.b20 - 384*m.b8*m.b16*m.b21 -
352*m.b8*m.b16*m.b22 - 320*m.b8*m.b16*m.b23 - 256*m.b8*m.b16*m.b24 - 512*m.b8*m.b16*m.b25 - 480*
m.b8*m.b16*m.b26 - 448*m.b8*m.b16*m.b27 - 416*m.b8*m.b16*m.b28 - 384*m.b8*m.b16*m.b29 - 352*m.b8*
m.b16*m.b30 - 320*m.b8*m.b16*m.b31 - 288*m.b8*m.b16*m.b32 - 256*m.b8*m.b16*m.b33 - 224*m.b8*m.b16
*m.b34 - 192*m.b8*m.b16*m.b35 - 160*m.b8*m.b16*m.b36 - 128*m.b8*m.b16*m.b37 - 96*m.b8*m.b16*m.b38
- 64*m.b8*m.b16*m.b39 - 32*m.b8*m.b16*m.b40 - 320*m.b8*m.b17*m.b18 - 320*m.b8*m.b17*m.b19 - 320*
m.b8*m.b17*m.b20 - 416*m.b8*m.b17*m.b21 - 384*m.b8*m.b17*m.b22 - 352*m.b8*m.b17*m.b23 - 544*m.b8*
m.b17*m.b24 - 480*m.b8*m.b17*m.b25 - 192*m.b8*m.b17*m.b26 - 416*m.b8*m.b17*m.b27 - 384*m.b8*m.b17
*m.b28 - 352*m.b8*m.b17*m.b29 - 320*m.b8*m.b17*m.b30 - 288*m.b8*m.b17*m.b31 - 256*m.b8*m.b17*
m.b32 - 256*m.b8*m.b17*m.b33 - 224*m.b8*m.b17*m.b34 - 192*m.b8*m.b17*m.b35 - 160*m.b8*m.b17*m.b36
- 128*m.b8*m.b17*m.b37 - 96*m.b8*m.b17*m.b38 - 64*m.b8*m.b17*m.b39 - 32*m.b8*m.b17*m.b40 - 320*
m.b8*m.b18*m.b19 - 320*m.b8*m.b18*m.b20 - 448*m.b8*m.b18*m.b21 - 416*m.b8*m.b18*m.b22 - 384*m.b8*
m.b18*m.b23 - 544*m.b8*m.b18*m.b24 - 480*m.b8*m.b18*m.b25 - 416*m.b8*m.b18*m.b26 - 384*m.b8*m.b18
*m.b27 - 96*m.b8*m.b18*m.b28 - 320*m.b8*m.b18*m.b29 - 288*m.b8*m.b18*m.b30 - 256*m.b8*m.b18*m.b31
- 256*m.b8*m.b18*m.b32 - 256*m.b8*m.b18*m.b33 - 224*m.b8*m.b18*m.b34 - 192*m.b8*m.b18*m.b35 -
160*m.b8*m.b18*m.b36 - 128*m.b8*m.b18*m.b37 - 96*m.b8*m.b18*m.b38 - 64*m.b8*m.b18*m.b39 - 32*m.b8
*m.b18*m.b40 - 320*m.b8*m.b19*m.b20 - 320*m.b8*m.b19*m.b21 - 448*m.b8*m.b19*m.b22 - 384*m.b8*
m.b19*m.b23 - 544*m.b8*m.b19*m.b24 - 480*m.b8*m.b19*m.b25 - 416*m.b8*m.b19*m.b26 - 352*m.b8*m.b19
*m.b27 - 320*m.b8*m.b19*m.b28 - 288*m.b8*m.b19*m.b29 - 256*m.b8*m.b19*m.b31 - 256*m.b8*m.b19*
m.b32 - 256*m.b8*m.b19*m.b33 - 224*m.b8*m.b19*m.b34 - 192*m.b8*m.b19*m.b35 - 160*m.b8*m.b19*m.b36
- 128*m.b8*m.b19*m.b37 - 96*m.b8*m.b19*m.b38 - 64*m.b8*m.b19*m.b39 - 32*m.b8*m.b19*m.b40 - 320*
m.b8*m.b20*m.b21 - 448*m.b8*m.b20*m.b22 - 384*m.b8*m.b20*m.b23 - 544*m.b8*m.b20*m.b24 - 480*m.b8*
m.b20*m.b25 - 416*m.b8*m.b20*m.b26 - 352*m.b8*m.b20*m.b27 - 288*m.b8*m.b20*m.b28 - 256*m.b8*m.b20
*m.b29 - 256*m.b8*m.b20*m.b30 - 256*m.b8*m.b20*m.b31 - 256*m.b8*m.b20*m.b33 - 224*m.b8*m.b20*
m.b34 - 192*m.b8*m.b20*m.b35 - 160*m.b8*m.b20*m.b36 - 128*m.b8*m.b20*m.b37 - 96*m.b8*m.b20*m.b38
- 64*m.b8*m.b20*m.b39 - 32*m.b8*m.b20*m.b40 - 256*m.b8*m.b21*m.b22 - 384*m.b8*m.b21*m.b23 - 544*
m.b8*m.b21*m.b24 - 480*m.b8*m.b21*m.b25 - 416*m.b8*m.b21*m.b26 - 352*m.b8*m.b21*m.b27 - 288*m.b8*
m.b21*m.b28 - 256*m.b8*m.b21*m.b29 - 256*m.b8*m.b21*m.b30 - 256*m.b8*m.b21*m.b31 - 256*m.b8*m.b21
*m.b32 - 256*m.b8*m.b21*m.b33 - 192*m.b8*m.b21*m.b35 - 160*m.b8*m.b21*m.b36 - 128*m.b8*m.b21*
m.b37 - 96*m.b8*m.b21*m.b38 - 64*m.b8*m.b21*m.b39 - 32*m.b8*m.b21*m.b40 - 384*m.b8*m.b22*m.b23 -
544*m.b8*m.b22*m.b24 - 480*m.b8*m.b22*m.b25 - 416*m.b8*m.b22*m.b26 - 352*m.b8*m.b22*m.b27 - 320*
m.b8*m.b22*m.b28 - 288*m.b8*m.b22*m.b29 - 256*m.b8*m.b22*m.b30 - 256*m.b8*m.b22*m.b31 - 256*m.b8*
m.b22*m.b32 - 256*m.b8*m.b22*m.b33 - 224*m.b8*m.b22*m.b34 - 192*m.b8*m.b22*m.b35 - 128*m.b8*m.b22
*m.b37 - 96*m.b8*m.b22*m.b38 - 64*m.b8*m.b22*m.b39 - 32*m.b8*m.b22*m.b40 - 544*m.b8*m.b23*m.b24
- 480*m.b8*m.b23*m.b25 - 416*m.b8*m.b23*m.b26 - 384*m.b8*m.b23*m.b27 - 352*m.b8*m.b23*m.b28 -
320*m.b8*m.b23*m.b29 - 288*m.b8*m.b23*m.b30 - 256*m.b8*m.b23*m.b31 - 256*m.b8*m.b23*m.b32 - 256*
m.b8*m.b23*m.b33 - 224*m.b8*m.b23*m.b34 - 192*m.b8*m.b23*m.b35 - 160*m.b8*m.b23*m.b36 - 128*m.b8*
m.b23*m.b37 - 64*m.b8*m.b23*m.b39 - 32*m.b8*m.b23*m.b40 - 480*m.b8*m.b24*m.b25 - 448*m.b8*m.b24*
m.b26 - 416*m.b8*m.b24*m.b27 - 384*m.b8*m.b24*m.b28 - 352*m.b8*m.b24*m.b29 - 320*m.b8*m.b24*m.b30
- 288*m.b8*m.b24*m.b31 - 256*m.b8*m.b24*m.b32 - 256*m.b8*m.b24*m.b33 - 224*m.b8*m.b24*m.b34 -
192*m.b8*m.b24*m.b35 - 160*m.b8*m.b24*m.b36 - 128*m.b8*m.b24*m.b37 - 96*m.b8*m.b24*m.b38 - 64*
m.b8*m.b24*m.b39 - 480*m.b8*m.b25*m.b26 - 448*m.b8*m.b25*m.b27 - 416*m.b8*m.b25*m.b28 - 384*m.b8*
m.b25*m.b29 - 352*m.b8*m.b25*m.b30 - 320*m.b8*m.b25*m.b31 - 288*m.b8*m.b25*m.b32 - 256*m.b8*m.b25
*m.b33 - 224*m.b8*m.b25*m.b34 - 192*m.b8*m.b25*m.b35 - 160*m.b8*m.b25*m.b36 - 128*m.b8*m.b25*
m.b37 - 96*m.b8*m.b25*m.b38 - 64*m.b8*m.b25*m.b39 - 32*m.b8*m.b25*m.b40 - 480*m.b8*m.b26*m.b27 -
448*m.b8*m.b26*m.b28 - 416*m.b8*m.b26*m.b29 - 384*m.b8*m.b26*m.b30 - 352*m.b8*m.b26*m.b31 - 320*
m.b8*m.b26*m.b32 - 288*m.b8*m.b26*m.b33 - 224*m.b8*m.b26*m.b34 - 192*m.b8*m.b26*m.b35 - 160*m.b8*
m.b26*m.b36 - 128*m.b8*m.b26*m.b37 - 96*m.b8*m.b26*m.b38 - 64*m.b8*m.b26*m.b39 - 32*m.b8*m.b26*
m.b40 - 480*m.b8*m.b27*m.b28 - 448*m.b8*m.b27*m.b29 - 416*m.b8*m.b27*m.b30 - 384*m.b8*m.b27*m.b31
- 352*m.b8*m.b27*m.b32 - 320*m.b8*m.b27*m.b33 - 256*m.b8*m.b27*m.b34 - 192*m.b8*m.b27*m.b35 -
160*m.b8*m.b27*m.b36 - 128*m.b8*m.b27*m.b37 - 96*m.b8*m.b27*m.b38 - 64*m.b8*m.b27*m.b39 - 32*m.b8
*m.b27*m.b40 - 480*m.b8*m.b28*m.b29 - 448*m.b8*m.b28*m.b30 - 416*m.b8*m.b28*m.b31 - 384*m.b8*
m.b28*m.b32 - 352*m.b8*m.b28*m.b33 - 288*m.b8*m.b28*m.b34 - 224*m.b8*m.b28*m.b35 - 160*m.b8*m.b28
*m.b36 - 128*m.b8*m.b28*m.b37 - 96*m.b8*m.b28*m.b38 - 64*m.b8*m.b28*m.b39 - 32*m.b8*m.b28*m.b40
- 480*m.b8*m.b29*m.b30 - 448*m.b8*m.b29*m.b31 - 416*m.b8*m.b29*m.b32 - 384*m.b8*m.b29*m.b33 -
320*m.b8*m.b29*m.b34 - 256*m.b8*m.b29*m.b35 - 192*m.b8*m.b29*m.b36 - 128*m.b8*m.b29*m.b37 - 96*
m.b8*m.b29*m.b38 - 64*m.b8*m.b29*m.b39 - 32*m.b8*m.b29*m.b40 - 480*m.b8*m.b30*m.b31 - 448*m.b8*
m.b30*m.b32 - 416*m.b8*m.b30*m.b33 - 352*m.b8*m.b30*m.b34 - 288*m.b8*m.b30*m.b35 - 224*m.b8*m.b30
*m.b36 - 160*m.b8*m.b30*m.b37 - 96*m.b8*m.b30*m.b38 - 64*m.b8*m.b30*m.b39 - 32*m.b8*m.b30*m.b40
- 480*m.b8*m.b31*m.b32 - 448*m.b8*m.b31*m.b33 - 384*m.b8*m.b31*m.b34 - 320*m.b8*m.b31*m.b35 -
256*m.b8*m.b31*m.b36 - 192*m.b8*m.b31*m.b37 - 128*m.b8*m.b31*m.b38 - 64*m.b8*m.b31*m.b39 - 32*
m.b8*m.b31*m.b40 - 480*m.b8*m.b32*m.b33 - 416*m.b8*m.b32*m.b34 - 352*m.b8*m.b32*m.b35 - 288*m.b8*
m.b32*m.b36 - 224*m.b8*m.b32*m.b37 - 160*m.b8*m.b32*m.b38 - 96*m.b8*m.b32*m.b39 - 32*m.b8*m.b32*
m.b40 - 448*m.b8*m.b33*m.b34 - 384*m.b8*m.b33*m.b35 - 320*m.b8*m.b33*m.b36 - 256*m.b8*m.b33*m.b37
- 192*m.b8*m.b33*m.b38 - 128*m.b8*m.b33*m.b39 - 64*m.b8*m.b33*m.b40 - 384*m.b8*m.b34*m.b35 - 320
*m.b8*m.b34*m.b36 - 256*m.b8*m.b34*m.b37 - 192*m.b8*m.b34*m.b38 - 128*m.b8*m.b34*m.b39 - 64*m.b8*
m.b34*m.b40 - 320*m.b8*m.b35*m.b36 - 256*m.b8*m.b35*m.b37 - 192*m.b8*m.b35*m.b38 - 128*m.b8*m.b35
*m.b39 - 64*m.b8*m.b35*m.b40 - 256*m.b8*m.b36*m.b37 - 192*m.b8*m.b36*m.b38 - 128*m.b8*m.b36*m.b39
- 64*m.b8*m.b36*m.b40 - 192*m.b8*m.b37*m.b38 - 128*m.b8*m.b37*m.b39 - 64*m.b8*m.b37*m.b40 - 128*
m.b8*m.b38*m.b39 - 64*m.b8*m.b38*m.b40 - 64*m.b8*m.b39*m.b40 - 64*m.b9*m.b10*m.b11 - 96*m.b9*
m.b10*m.b12 - 96*m.b9*m.b10*m.b13 - 96*m.b9*m.b10*m.b14 - 96*m.b9*m.b10*m.b15 - 96*m.b9*m.b10*
m.b16 - 96*m.b9*m.b10*m.b17 - 96*m.b9*m.b10*m.b18 - 64*m.b9*m.b10*m.b19 - 64*m.b9*m.b10*m.b20 -
64*m.b9*m.b10*m.b21 - 64*m.b9*m.b10*m.b22 - 64*m.b9*m.b10*m.b23 - 320*m.b9*m.b10*m.b24 - 576*m.b9
*m.b10*m.b25 - 576*m.b9*m.b10*m.b26 - 576*m.b9*m.b10*m.b27 - 576*m.b9*m.b10*m.b28 - 576*m.b9*
m.b10*m.b29 - 576*m.b9*m.b10*m.b30 - 576*m.b9*m.b10*m.b31 - 544*m.b9*m.b10*m.b32 - 480*m.b9*m.b10
*m.b33 - 416*m.b9*m.b10*m.b34 - 352*m.b9*m.b10*m.b35 - 288*m.b9*m.b10*m.b36 - 224*m.b9*m.b10*
m.b37 - 160*m.b9*m.b10*m.b38 - 96*m.b9*m.b10*m.b39 - 32*m.b9*m.b10*m.b40 - 96*m.b9*m.b11*m.b12 -
64*m.b9*m.b11*m.b13 - 96*m.b9*m.b11*m.b14 - 96*m.b9*m.b11*m.b15 - 96*m.b9*m.b11*m.b16 - 96*m.b9*
m.b11*m.b17 - 128*m.b9*m.b11*m.b18 - 96*m.b9*m.b11*m.b19 - 64*m.b9*m.b11*m.b20 - 64*m.b9*m.b11*
m.b21 - 64*m.b9*m.b11*m.b22 - 320*m.b9*m.b11*m.b23 - 320*m.b9*m.b11*m.b24 - 576*m.b9*m.b11*m.b25
- 576*m.b9*m.b11*m.b26 - 576*m.b9*m.b11*m.b27 - 576*m.b9*m.b11*m.b28 - 576*m.b9*m.b11*m.b29 -
576*m.b9*m.b11*m.b30 - 544*m.b9*m.b11*m.b31 - 512*m.b9*m.b11*m.b32 - 448*m.b9*m.b11*m.b33 - 384*
m.b9*m.b11*m.b34 - 320*m.b9*m.b11*m.b35 - 256*m.b9*m.b11*m.b36 - 192*m.b9*m.b11*m.b37 - 128*m.b9*
m.b11*m.b38 - 64*m.b9*m.b11*m.b39 - 32*m.b9*m.b11*m.b40 - 96*m.b9*m.b12*m.b13 - 96*m.b9*m.b12*
m.b14 - 64*m.b9*m.b12*m.b15 - 96*m.b9*m.b12*m.b16 - 96*m.b9*m.b12*m.b17 - 96*m.b9*m.b12*m.b18 -
128*m.b9*m.b12*m.b19 - 96*m.b9*m.b12*m.b20 - 64*m.b9*m.b12*m.b21 - 320*m.b9*m.b12*m.b22 - 320*
m.b9*m.b12*m.b23 - 320*m.b9*m.b12*m.b24 - 576*m.b9*m.b12*m.b25 - 576*m.b9*m.b12*m.b26 - 576*m.b9*
m.b12*m.b27 - 576*m.b9*m.b12*m.b28 - 576*m.b9*m.b12*m.b29 - 544*m.b9*m.b12*m.b30 - 512*m.b9*m.b12
*m.b31 - 480*m.b9*m.b12*m.b32 - 416*m.b9*m.b12*m.b33 - 352*m.b9*m.b12*m.b34 - 288*m.b9*m.b12*
m.b35 - 224*m.b9*m.b12*m.b36 - 160*m.b9*m.b12*m.b37 - 96*m.b9*m.b12*m.b38 - 64*m.b9*m.b12*m.b39
- 32*m.b9*m.b12*m.b40 - 96*m.b9*m.b13*m.b14 - 96*m.b9*m.b13*m.b15 - 96*m.b9*m.b13*m.b16 - 64*
m.b9*m.b13*m.b17 - 96*m.b9*m.b13*m.b18 - 160*m.b9*m.b13*m.b19 - 128*m.b9*m.b13*m.b20 - 352*m.b9*
m.b13*m.b21 - 320*m.b9*m.b13*m.b22 - 320*m.b9*m.b13*m.b23 - 320*m.b9*m.b13*m.b24 - 576*m.b9*m.b13
*m.b25 - 576*m.b9*m.b13*m.b26 - 576*m.b9*m.b13*m.b27 - 576*m.b9*m.b13*m.b28 - 544*m.b9*m.b13*
m.b29 - 512*m.b9*m.b13*m.b30 - 480*m.b9*m.b13*m.b31 - 448*m.b9*m.b13*m.b32 - 384*m.b9*m.b13*m.b33
- 320*m.b9*m.b13*m.b34 - 256*m.b9*m.b13*m.b35 - 192*m.b9*m.b13*m.b36 - 128*m.b9*m.b13*m.b37 - 96
*m.b9*m.b13*m.b38 - 64*m.b9*m.b13*m.b39 - 32*m.b9*m.b13*m.b40 - 96*m.b9*m.b14*m.b15 - 96*m.b9*
m.b14*m.b16 - 96*m.b9*m.b14*m.b17 - 96*m.b9*m.b14*m.b18 - 64*m.b9*m.b14*m.b19 - 416*m.b9*m.b14*
m.b20 - 384*m.b9*m.b14*m.b21 - 352*m.b9*m.b14*m.b22 - 320*m.b9*m.b14*m.b23 - 320*m.b9*m.b14*m.b24
- 576*m.b9*m.b14*m.b25 - 576*m.b9*m.b14*m.b26 - 576*m.b9*m.b14*m.b27 - 544*m.b9*m.b14*m.b28 -
512*m.b9*m.b14*m.b29 - 480*m.b9*m.b14*m.b30 - 448*m.b9*m.b14*m.b31 - 416*m.b9*m.b14*m.b32 - 352*
m.b9*m.b14*m.b33 - 288*m.b9*m.b14*m.b34 - 224*m.b9*m.b14*m.b35 - 160*m.b9*m.b14*m.b36 - 128*m.b9*
m.b14*m.b37 - 96*m.b9*m.b14*m.b38 - 64*m.b9*m.b14*m.b39 - 32*m.b9*m.b14*m.b40 - 96*m.b9*m.b15*
m.b16 - 96*m.b9*m.b15*m.b17 - 96*m.b9*m.b15*m.b18 - 352*m.b9*m.b15*m.b19 - 448*m.b9*m.b15*m.b20
- 384*m.b9*m.b15*m.b21 - 384*m.b9*m.b15*m.b22 - 352*m.b9*m.b15*m.b23 - 320*m.b9*m.b15*m.b24 -
576*m.b9*m.b15*m.b25 - 576*m.b9*m.b15*m.b26 - 544*m.b9*m.b15*m.b27 - 512*m.b9*m.b15*m.b28 - 480*
m.b9*m.b15*m.b29 - 448*m.b9*m.b15*m.b30 - 416*m.b9*m.b15*m.b31 - 384*m.b9*m.b15*m.b32 - 320*m.b9*
m.b15*m.b33 - 256*m.b9*m.b15*m.b34 - 192*m.b9*m.b15*m.b35 - 160*m.b9*m.b15*m.b36 - 128*m.b9*m.b15
*m.b37 - 96*m.b9*m.b15*m.b38 - 64*m.b9*m.b15*m.b39 - 32*m.b9*m.b15*m.b40 - 96*m.b9*m.b16*m.b17 -
352*m.b9*m.b16*m.b18 - 352*m.b9*m.b16*m.b19 - 352*m.b9*m.b16*m.b20 - 448*m.b9*m.b16*m.b21 - 416*
m.b9*m.b16*m.b22 - 352*m.b9*m.b16*m.b23 - 352*m.b9*m.b16*m.b24 - 576*m.b9*m.b16*m.b25 - 544*m.b9*
m.b16*m.b26 - 512*m.b9*m.b16*m.b27 - 480*m.b9*m.b16*m.b28 - 448*m.b9*m.b16*m.b29 - 416*m.b9*m.b16
*m.b30 - 384*m.b9*m.b16*m.b31 - 352*m.b9*m.b16*m.b32 - 288*m.b9*m.b16*m.b33 - 224*m.b9*m.b16*
m.b34 - 192*m.b9*m.b16*m.b35 - 160*m.b9*m.b16*m.b36 - 128*m.b9*m.b16*m.b37 - 96*m.b9*m.b16*m.b38
- 64*m.b9*m.b16*m.b39 - 32*m.b9*m.b16*m.b40 - 352*m.b9*m.b17*m.b18 - 352*m.b9*m.b17*m.b19 - 352*
m.b9*m.b17*m.b20 - 480*m.b9*m.b17*m.b21 - 448*m.b9*m.b17*m.b22 - 416*m.b9*m.b17*m.b23 - 384*m.b9*
m.b17*m.b24 - 288*m.b9*m.b17*m.b25 - 512*m.b9*m.b17*m.b26 - 480*m.b9*m.b17*m.b27 - 448*m.b9*m.b17
*m.b28 - 416*m.b9*m.b17*m.b29 - 384*m.b9*m.b17*m.b30 - 352*m.b9*m.b17*m.b31 - 320*m.b9*m.b17*
m.b32 - 256*m.b9*m.b17*m.b33 - 224*m.b9*m.b17*m.b34 - 192*m.b9*m.b17*m.b35 - 160*m.b9*m.b17*m.b36
- 128*m.b9*m.b17*m.b37 - 96*m.b9*m.b17*m.b38 - 64*m.b9*m.b17*m.b39 - 32*m.b9*m.b17*m.b40 - 352*
m.b9*m.b18*m.b19 - 352*m.b9*m.b18*m.b20 - 352*m.b9*m.b18*m.b21 - 480*m.b9*m.b18*m.b22 - 448*m.b9*
m.b18*m.b23 - 384*m.b9*m.b18*m.b24 - 576*m.b9*m.b18*m.b25 - 512*m.b9*m.b18*m.b26 - 160*m.b9*m.b18
*m.b27 - 416*m.b9*m.b18*m.b28 - 384*m.b9*m.b18*m.b29 - 352*m.b9*m.b18*m.b30 - 320*m.b9*m.b18*
m.b31 - 288*m.b9*m.b18*m.b32 - 256*m.b9*m.b18*m.b33 - 224*m.b9*m.b18*m.b34 - 192*m.b9*m.b18*m.b35
- 160*m.b9*m.b18*m.b36 - 128*m.b9*m.b18*m.b37 - 96*m.b9*m.b18*m.b38 - 64*m.b9*m.b18*m.b39 - 32*
m.b9*m.b18*m.b40 - 352*m.b9*m.b19*m.b20 - 352*m.b9*m.b19*m.b21 - 512*m.b9*m.b19*m.b22 - 448*m.b9*
m.b19*m.b23 - 384*m.b9*m.b19*m.b24 - 576*m.b9*m.b19*m.b25 - 512*m.b9*m.b19*m.b26 - 448*m.b9*m.b19
*m.b27 - 384*m.b9*m.b19*m.b28 - 64*m.b9*m.b19*m.b29 - 320*m.b9*m.b19*m.b30 - 288*m.b9*m.b19*m.b31
- 288*m.b9*m.b19*m.b32 - 256*m.b9*m.b19*m.b33 - 224*m.b9*m.b19*m.b34 - 192*m.b9*m.b19*m.b35 -
160*m.b9*m.b19*m.b36 - 128*m.b9*m.b19*m.b37 - 96*m.b9*m.b19*m.b38 - 64*m.b9*m.b19*m.b39 - 32*m.b9
*m.b19*m.b40 - 352*m.b9*m.b20*m.b21 - 320*m.b9*m.b20*m.b22 - 448*m.b9*m.b20*m.b23 - 384*m.b9*
m.b20*m.b24 - 576*m.b9*m.b20*m.b25 - 512*m.b9*m.b20*m.b26 - 448*m.b9*m.b20*m.b27 - 384*m.b9*m.b20
*m.b28 - 320*m.b9*m.b20*m.b29 - 288*m.b9*m.b20*m.b30 - 288*m.b9*m.b20*m.b32 - 256*m.b9*m.b20*
m.b33 - 224*m.b9*m.b20*m.b34 - 192*m.b9*m.b20*m.b35 - 160*m.b9*m.b20*m.b36 - 128*m.b9*m.b20*m.b37
- 96*m.b9*m.b20*m.b38 - 64*m.b9*m.b20*m.b39 - 32*m.b9*m.b20*m.b40 - 288*m.b9*m.b21*m.b22 - 448*
m.b9*m.b21*m.b23 - 384*m.b9*m.b21*m.b24 - 576*m.b9*m.b21*m.b25 - 512*m.b9*m.b21*m.b26 - 448*m.b9*
m.b21*m.b27 - 384*m.b9*m.b21*m.b28 - 320*m.b9*m.b21*m.b29 - 288*m.b9*m.b21*m.b30 - 288*m.b9*m.b21
*m.b31 - 288*m.b9*m.b21*m.b32 - 224*m.b9*m.b21*m.b34 - 192*m.b9*m.b21*m.b35 - 160*m.b9*m.b21*
m.b36 - 128*m.b9*m.b21*m.b37 - 96*m.b9*m.b21*m.b38 - 64*m.b9*m.b21*m.b39 - 32*m.b9*m.b21*m.b40 -
224*m.b9*m.b22*m.b23 - 384*m.b9*m.b22*m.b24 - 576*m.b9*m.b22*m.b25 - 512*m.b9*m.b22*m.b26 - 448*
m.b9*m.b22*m.b27 - 384*m.b9*m.b22*m.b28 - 352*m.b9*m.b22*m.b29 - 320*m.b9*m.b22*m.b30 - 288*m.b9*
m.b22*m.b31 - 288*m.b9*m.b22*m.b32 - 256*m.b9*m.b22*m.b33 - 224*m.b9*m.b22*m.b34 - 160*m.b9*m.b22
*m.b36 - 128*m.b9*m.b22*m.b37 - 96*m.b9*m.b22*m.b38 - 64*m.b9*m.b22*m.b39 - 32*m.b9*m.b22*m.b40
- 384*m.b9*m.b23*m.b24 - 576*m.b9*m.b23*m.b25 - 512*m.b9*m.b23*m.b26 - 448*m.b9*m.b23*m.b27 -
416*m.b9*m.b23*m.b28 - 384*m.b9*m.b23*m.b29 - 352*m.b9*m.b23*m.b30 - 320*m.b9*m.b23*m.b31 - 288*
m.b9*m.b23*m.b32 - 256*m.b9*m.b23*m.b33 - 224*m.b9*m.b23*m.b34 - 192*m.b9*m.b23*m.b35 - 160*m.b9*
m.b23*m.b36 - 96*m.b9*m.b23*m.b38 - 64*m.b9*m.b23*m.b39 - 32*m.b9*m.b23*m.b40 - 576*m.b9*m.b24*
m.b25 - 512*m.b9*m.b24*m.b26 - 480*m.b9*m.b24*m.b27 - 448*m.b9*m.b24*m.b28 - 416*m.b9*m.b24*m.b29
- 384*m.b9*m.b24*m.b30 - 352*m.b9*m.b24*m.b31 - 320*m.b9*m.b24*m.b32 - 256*m.b9*m.b24*m.b33 -
224*m.b9*m.b24*m.b34 - 192*m.b9*m.b24*m.b35 - 160*m.b9*m.b24*m.b36 - 128*m.b9*m.b24*m.b37 - 96*
m.b9*m.b24*m.b38 - 32*m.b9*m.b24*m.b40 - 544*m.b9*m.b25*m.b26 - 512*m.b9*m.b25*m.b27 - 480*m.b9*
m.b25*m.b28 - 448*m.b9*m.b25*m.b29 - 416*m.b9*m.b25*m.b30 - 384*m.b9*m.b25*m.b31 - 352*m.b9*m.b25
*m.b32 - 288*m.b9*m.b25*m.b33 - 224*m.b9*m.b25*m.b34 - 192*m.b9*m.b25*m.b35 - 160*m.b9*m.b25*
m.b36 - 128*m.b9*m.b25*m.b37 - 96*m.b9*m.b25*m.b38 - 64*m.b9*m.b25*m.b39 - 32*m.b9*m.b25*m.b40 -
544*m.b9*m.b26*m.b27 - 512*m.b9*m.b26*m.b28 - 480*m.b9*m.b26*m.b29 - 448*m.b9*m.b26*m.b30 - 416*
m.b9*m.b26*m.b31 - 384*m.b9*m.b26*m.b32 - 320*m.b9*m.b26*m.b33 - 256*m.b9*m.b26*m.b34 - 192*m.b9*
m.b26*m.b35 - 160*m.b9*m.b26*m.b36 - 128*m.b9*m.b26*m.b37 - 96*m.b9*m.b26*m.b38 - 64*m.b9*m.b26*
m.b39 - 32*m.b9*m.b26*m.b40 - 544*m.b9*m.b27*m.b28 - 512*m.b9*m.b27*m.b29 - 480*m.b9*m.b27*m.b30
- 448*m.b9*m.b27*m.b31 - 416*m.b9*m.b27*m.b32 - 352*m.b9*m.b27*m.b33 - 288*m.b9*m.b27*m.b34 -
224*m.b9*m.b27*m.b35 - 160*m.b9*m.b27*m.b36 - 128*m.b9*m.b27*m.b37 - 96*m.b9*m.b27*m.b38 - 64*
m.b9*m.b27*m.b39 - 32*m.b9*m.b27*m.b40 - 544*m.b9*m.b28*m.b29 - 512*m.b9*m.b28*m.b30 - 480*m.b9*
m.b28*m.b31 - 448*m.b9*m.b28*m.b32 - 384*m.b9*m.b28*m.b33 - 320*m.b9*m.b28*m.b34 - 256*m.b9*m.b28
*m.b35 - 192*m.b9*m.b28*m.b36 - 128*m.b9*m.b28*m.b37 - 96*m.b9*m.b28*m.b38 - 64*m.b9*m.b28*m.b39
- 32*m.b9*m.b28*m.b40 - 544*m.b9*m.b29*m.b30 - 512*m.b9*m.b29*m.b31 - 480*m.b9*m.b29*m.b32 - 416
*m.b9*m.b29*m.b33 - 352*m.b9*m.b29*m.b34 - 288*m.b9*m.b29*m.b35 - 224*m.b9*m.b29*m.b36 - 160*m.b9
*m.b29*m.b37 - 96*m.b9*m.b29*m.b38 - 64*m.b9*m.b29*m.b39 - 32*m.b9*m.b29*m.b40 - 544*m.b9*m.b30*
m.b31 - 512*m.b9*m.b30*m.b32 - 448*m.b9*m.b30*m.b33 - 384*m.b9*m.b30*m.b34 - 320*m.b9*m.b30*m.b35
- 256*m.b9*m.b30*m.b36 - 192*m.b9*m.b30*m.b37 - 128*m.b9*m.b30*m.b38 - 64*m.b9*m.b30*m.b39 - 32*
m.b9*m.b30*m.b40 - 544*m.b9*m.b31*m.b32 - 480*m.b9*m.b31*m.b33 - 416*m.b9*m.b31*m.b34 - 352*m.b9*
m.b31*m.b35 - 288*m.b9*m.b31*m.b36 - 224*m.b9*m.b31*m.b37 - 160*m.b9*m.b31*m.b38 - 96*m.b9*m.b31*
m.b39 - 32*m.b9*m.b31*m.b40 - 512*m.b9*m.b32*m.b33 - 448*m.b9*m.b32*m.b34 - 384*m.b9*m.b32*m.b35
- 320*m.b9*m.b32*m.b36 - 256*m.b9*m.b32*m.b37 - 192*m.b9*m.b32*m.b38 - 128*m.b9*m.b32*m.b39 - 64
*m.b9*m.b32*m.b40 - 448*m.b9*m.b33*m.b34 - 384*m.b9*m.b33*m.b35 - 320*m.b9*m.b33*m.b36 - 256*m.b9
*m.b33*m.b37 - 192*m.b9*m.b33*m.b38 - 128*m.b9*m.b33*m.b39 - 64*m.b9*m.b33*m.b40 - 384*m.b9*m.b34
*m.b35 - 320*m.b9*m.b34*m.b36 - 256*m.b9*m.b34*m.b37 - 192*m.b9*m.b34*m.b38 - 128*m.b9*m.b34*
m.b39 - 64*m.b9*m.b34*m.b40 - 320*m.b9*m.b35*m.b36 - 256*m.b9*m.b35*m.b37 - 192*m.b9*m.b35*m.b38
- 128*m.b9*m.b35*m.b39 - 64*m.b9*m.b35*m.b40 - 256*m.b9*m.b36*m.b37 - 192*m.b9*m.b36*m.b38 - 128
*m.b9*m.b36*m.b39 - 64*m.b9*m.b36*m.b40 - 192*m.b9*m.b37*m.b38 - 128*m.b9*m.b37*m.b39 - 64*m.b9*
m.b37*m.b40 - 128*m.b9*m.b38*m.b39 - 64*m.b9*m.b38*m.b40 - 64*m.b9*m.b39*m.b40 - 64*m.b10*m.b11*
m.b12 - 96*m.b10*m.b11*m.b13 - 96*m.b10*m.b11*m.b14 - 96*m.b10*m.b11*m.b15 - 96*m.b10*m.b11*m.b16
- 96*m.b10*m.b11*m.b17 - 96*m.b10*m.b11*m.b18 - 128*m.b10*m.b11*m.b19 - 96*m.b10*m.b11*m.b20 -
64*m.b10*m.b11*m.b21 - 64*m.b10*m.b11*m.b22 - 64*m.b10*m.b11*m.b23 - 64*m.b10*m.b11*m.b24 - 352*
m.b10*m.b11*m.b25 - 640*m.b10*m.b11*m.b26 - 640*m.b10*m.b11*m.b27 - 640*m.b10*m.b11*m.b28 - 640*
m.b10*m.b11*m.b29 - 640*m.b10*m.b11*m.b30 - 608*m.b10*m.b11*m.b31 - 544*m.b10*m.b11*m.b32 - 480*
m.b10*m.b11*m.b33 - 416*m.b10*m.b11*m.b34 - 352*m.b10*m.b11*m.b35 - 288*m.b10*m.b11*m.b36 - 224*
m.b10*m.b11*m.b37 - 160*m.b10*m.b11*m.b38 - 96*m.b10*m.b11*m.b39 - 32*m.b10*m.b11*m.b40 - 96*
m.b10*m.b12*m.b13 - 64*m.b10*m.b12*m.b14 - 96*m.b10*m.b12*m.b15 - 96*m.b10*m.b12*m.b16 - 96*m.b10
*m.b12*m.b17 - 96*m.b10*m.b12*m.b18 - 160*m.b10*m.b12*m.b19 - 128*m.b10*m.b12*m.b20 - 96*m.b10*
m.b12*m.b21 - 64*m.b10*m.b12*m.b22 - 64*m.b10*m.b12*m.b23 - 352*m.b10*m.b12*m.b24 - 352*m.b10*
m.b12*m.b25 - 640*m.b10*m.b12*m.b26 - 640*m.b10*m.b12*m.b27 - 640*m.b10*m.b12*m.b28 - 640*m.b10*
m.b12*m.b29 - 608*m.b10*m.b12*m.b30 - 576*m.b10*m.b12*m.b31 - 512*m.b10*m.b12*m.b32 - 448*m.b10*
m.b12*m.b33 - 384*m.b10*m.b12*m.b34 - 320*m.b10*m.b12*m.b35 - 256*m.b10*m.b12*m.b36 - 192*m.b10*
m.b12*m.b37 - 128*m.b10*m.b12*m.b38 - 64*m.b10*m.b12*m.b39 - 32*m.b10*m.b12*m.b40 - 96*m.b10*
m.b13*m.b14 - 96*m.b10*m.b13*m.b15 - 64*m.b10*m.b13*m.b16 - 96*m.b10*m.b13*m.b17 - 96*m.b10*m.b13
*m.b18 - 96*m.b10*m.b13*m.b19 - 160*m.b10*m.b13*m.b20 - 128*m.b10*m.b13*m.b21 - 96*m.b10*m.b13*
m.b22 - 352*m.b10*m.b13*m.b23 - 352*m.b10*m.b13*m.b24 - 352*m.b10*m.b13*m.b25 - 640*m.b10*m.b13*
m.b26 - 640*m.b10*m.b13*m.b27 - 640*m.b10*m.b13*m.b28 - 608*m.b10*m.b13*m.b29 - 576*m.b10*m.b13*
m.b30 - 544*m.b10*m.b13*m.b31 - 480*m.b10*m.b13*m.b32 - 416*m.b10*m.b13*m.b33 - 352*m.b10*m.b13*
m.b34 - 288*m.b10*m.b13*m.b35 - 224*m.b10*m.b13*m.b36 - 160*m.b10*m.b13*m.b37 - 96*m.b10*m.b13*
m.b38 - 64*m.b10*m.b13*m.b39 - 32*m.b10*m.b13*m.b40 - 96*m.b10*m.b14*m.b15 - 96*m.b10*m.b14*m.b16
- 96*m.b10*m.b14*m.b17 - 64*m.b10*m.b14*m.b18 - 96*m.b10*m.b14*m.b19 - 192*m.b10*m.b14*m.b20 -
160*m.b10*m.b14*m.b21 - 416*m.b10*m.b14*m.b22 - 384*m.b10*m.b14*m.b23 - 352*m.b10*m.b14*m.b24 -
352*m.b10*m.b14*m.b25 - 640*m.b10*m.b14*m.b26 - 640*m.b10*m.b14*m.b27 - 608*m.b10*m.b14*m.b28 -
576*m.b10*m.b14*m.b29 - 544*m.b10*m.b14*m.b30 - 512*m.b10*m.b14*m.b31 - 448*m.b10*m.b14*m.b32 -
384*m.b10*m.b14*m.b33 - 320*m.b10*m.b14*m.b34 - 256*m.b10*m.b14*m.b35 - 192*m.b10*m.b14*m.b36 -
128*m.b10*m.b14*m.b37 - 96*m.b10*m.b14*m.b38 - 64*m.b10*m.b14*m.b39 - 32*m.b10*m.b14*m.b40 - 96*
m.b10*m.b15*m.b16 - 96*m.b10*m.b15*m.b17 - 96*m.b10*m.b15*m.b18 - 96*m.b10*m.b15*m.b19 - 64*m.b10
*m.b15*m.b20 - 480*m.b10*m.b15*m.b21 - 448*m.b10*m.b15*m.b22 - 416*m.b10*m.b15*m.b23 - 384*m.b10*
m.b15*m.b24 - 352*m.b10*m.b15*m.b25 - 640*m.b10*m.b15*m.b26 - 608*m.b10*m.b15*m.b27 - 576*m.b10*
m.b15*m.b28 - 544*m.b10*m.b15*m.b29 - 512*m.b10*m.b15*m.b30 - 480*m.b10*m.b15*m.b31 - 416*m.b10*
m.b15*m.b32 - 352*m.b10*m.b15*m.b33 - 288*m.b10*m.b15*m.b34 - 224*m.b10*m.b15*m.b35 - 160*m.b10*
m.b15*m.b36 - 128*m.b10*m.b15*m.b37 - 96*m.b10*m.b15*m.b38 - 64*m.b10*m.b15*m.b39 - 32*m.b10*
m.b15*m.b40 - 96*m.b10*m.b16*m.b17 - 96*m.b10*m.b16*m.b18 - 96*m.b10*m.b16*m.b19 - 384*m.b10*
m.b16*m.b20 - 512*m.b10*m.b16*m.b21 - 448*m.b10*m.b16*m.b22 - 448*m.b10*m.b16*m.b23 - 416*m.b10*
m.b16*m.b24 - 384*m.b10*m.b16*m.b25 - 608*m.b10*m.b16*m.b26 - 576*m.b10*m.b16*m.b27 - 544*m.b10*
m.b16*m.b28 - 512*m.b10*m.b16*m.b29 - 480*m.b10*m.b16*m.b30 - 448*m.b10*m.b16*m.b31 - 384*m.b10*
m.b16*m.b32 - 320*m.b10*m.b16*m.b33 - 256*m.b10*m.b16*m.b34 - 192*m.b10*m.b16*m.b35 - 160*m.b10*
m.b16*m.b36 - 128*m.b10*m.b16*m.b37 - 96*m.b10*m.b16*m.b38 - 64*m.b10*m.b16*m.b39 - 32*m.b10*
m.b16*m.b40 - 96*m.b10*m.b17*m.b18 - 384*m.b10*m.b17*m.b19 - 384*m.b10*m.b17*m.b20 - 384*m.b10*
m.b17*m.b21 - 512*m.b10*m.b17*m.b22 - 480*m.b10*m.b17*m.b23 - 416*m.b10*m.b17*m.b24 - 384*m.b10*
m.b17*m.b25 - 608*m.b10*m.b17*m.b26 - 544*m.b10*m.b17*m.b27 - 512*m.b10*m.b17*m.b28 - 480*m.b10*
m.b17*m.b29 - 448*m.b10*m.b17*m.b30 - 416*m.b10*m.b17*m.b31 - 352*m.b10*m.b17*m.b32 - 288*m.b10*
m.b17*m.b33 - 224*m.b10*m.b17*m.b34 - 192*m.b10*m.b17*m.b35 - 160*m.b10*m.b17*m.b36 - 128*m.b10*
m.b17*m.b37 - 96*m.b10*m.b17*m.b38 - 64*m.b10*m.b17*m.b39 - 32*m.b10*m.b17*m.b40 - 384*m.b10*
m.b18*m.b19 - 384*m.b10*m.b18*m.b20 - 384*m.b10*m.b18*m.b21 - 544*m.b10*m.b18*m.b22 - 512*m.b10*
m.b18*m.b23 - 448*m.b10*m.b18*m.b24 - 384*m.b10*m.b18*m.b25 - 288*m.b10*m.b18*m.b26 - 544*m.b10*
m.b18*m.b27 - 480*m.b10*m.b18*m.b28 - 448*m.b10*m.b18*m.b29 - 416*m.b10*m.b18*m.b30 - 384*m.b10*
m.b18*m.b31 - 320*m.b10*m.b18*m.b32 - 256*m.b10*m.b18*m.b33 - 224*m.b10*m.b18*m.b34 - 192*m.b10*
m.b18*m.b35 - 160*m.b10*m.b18*m.b36 - 128*m.b10*m.b18*m.b37 - 96*m.b10*m.b18*m.b38 - 64*m.b10*
m.b18*m.b39 - 32*m.b10*m.b18*m.b40 - 384*m.b10*m.b19*m.b20 - 384*m.b10*m.b19*m.b21 - 384*m.b10*
m.b19*m.b22 - 512*m.b10*m.b19*m.b23 - 448*m.b10*m.b19*m.b24 - 384*m.b10*m.b19*m.b25 - 608*m.b10*
m.b19*m.b26 - 544*m.b10*m.b19*m.b27 - 160*m.b10*m.b19*m.b28 - 416*m.b10*m.b19*m.b29 - 384*m.b10*
m.b19*m.b30 - 352*m.b10*m.b19*m.b31 - 288*m.b10*m.b19*m.b32 - 256*m.b10*m.b19*m.b33 - 224*m.b10*
m.b19*m.b34 - 192*m.b10*m.b19*m.b35 - 160*m.b10*m.b19*m.b36 - 128*m.b10*m.b19*m.b37 - 96*m.b10*
m.b19*m.b38 - 64*m.b10*m.b19*m.b39 - 32*m.b10*m.b19*m.b40 - 384*m.b10*m.b20*m.b21 - 352*m.b10*
m.b20*m.b22 - 512*m.b10*m.b20*m.b23 - 448*m.b10*m.b20*m.b24 - 384*m.b10*m.b20*m.b25 - 608*m.b10*
m.b20*m.b26 - 544*m.b10*m.b20*m.b27 - 480*m.b10*m.b20*m.b28 - 416*m.b10*m.b20*m.b29 - 32*m.b10*
m.b20*m.b30 - 320*m.b10*m.b20*m.b31 - 288*m.b10*m.b20*m.b32 - 256*m.b10*m.b20*m.b33 - 224*m.b10*
m.b20*m.b34 - 192*m.b10*m.b20*m.b35 - 160*m.b10*m.b20*m.b36 - 128*m.b10*m.b20*m.b37 - 96*m.b10*
m.b20*m.b38 - 64*m.b10*m.b20*m.b39 - 32*m.b10*m.b20*m.b40 - 320*m.b10*m.b21*m.b22 - 288*m.b10*
m.b21*m.b23 - 448*m.b10*m.b21*m.b24 - 384*m.b10*m.b21*m.b25 - 608*m.b10*m.b21*m.b26 - 544*m.b10*
m.b21*m.b27 - 480*m.b10*m.b21*m.b28 - 416*m.b10*m.b21*m.b29 - 352*m.b10*m.b21*m.b30 - 320*m.b10*
m.b21*m.b31 - 256*m.b10*m.b21*m.b33 - 224*m.b10*m.b21*m.b34 - 192*m.b10*m.b21*m.b35 - 160*m.b10*
m.b21*m.b36 - 128*m.b10*m.b21*m.b37 - 96*m.b10*m.b21*m.b38 - 64*m.b10*m.b21*m.b39 - 32*m.b10*
m.b21*m.b40 - 256*m.b10*m.b22*m.b23 - 448*m.b10*m.b22*m.b24 - 384*m.b10*m.b22*m.b25 - 608*m.b10*
m.b22*m.b26 - 544*m.b10*m.b22*m.b27 - 480*m.b10*m.b22*m.b28 - 416*m.b10*m.b22*m.b29 - 384*m.b10*
m.b22*m.b30 - 352*m.b10*m.b22*m.b31 - 288*m.b10*m.b22*m.b32 - 256*m.b10*m.b22*m.b33 - 192*m.b10*
m.b22*m.b35 - 160*m.b10*m.b22*m.b36 - 128*m.b10*m.b22*m.b37 - 96*m.b10*m.b22*m.b38 - 64*m.b10*
m.b22*m.b39 - 32*m.b10*m.b22*m.b40 - 192*m.b10*m.b23*m.b24 - 384*m.b10*m.b23*m.b25 - 608*m.b10*
m.b23*m.b26 - 544*m.b10*m.b23*m.b27 - 480*m.b10*m.b23*m.b28 - 448*m.b10*m.b23*m.b29 - 416*m.b10*
m.b23*m.b30 - 384*m.b10*m.b23*m.b31 - 320*m.b10*m.b23*m.b32 - 256*m.b10*m.b23*m.b33 - 224*m.b10*
m.b23*m.b34 - 192*m.b10*m.b23*m.b35 - 128*m.b10*m.b23*m.b37 - 96*m.b10*m.b23*m.b38 - 64*m.b10*
m.b23*m.b39 - 32*m.b10*m.b23*m.b40 - 384*m.b10*m.b24*m.b25 - 608*m.b10*m.b24*m.b26 - 544*m.b10*
m.b24*m.b27 - 512*m.b10*m.b24*m.b28 - 480*m.b10*m.b24*m.b29 - 448*m.b10*m.b24*m.b30 - 416*m.b10*
m.b24*m.b31 - 352*m.b10*m.b24*m.b32 - 288*m.b10*m.b24*m.b33 - 224*m.b10*m.b24*m.b34 - 192*m.b10*
m.b24*m.b35 - 160*m.b10*m.b24*m.b36 - 128*m.b10*m.b24*m.b37 - 64*m.b10*m.b24*m.b39 - 32*m.b10*
m.b24*m.b40 - 608*m.b10*m.b25*m.b26 - 576*m.b10*m.b25*m.b27 - 544*m.b10*m.b25*m.b28 - 512*m.b10*
m.b25*m.b29 - 480*m.b10*m.b25*m.b30 - 448*m.b10*m.b25*m.b31 - 384*m.b10*m.b25*m.b32 - 320*m.b10*
m.b25*m.b33 - 256*m.b10*m.b25*m.b34 - 192*m.b10*m.b25*m.b35 - 160*m.b10*m.b25*m.b36 - 128*m.b10*
m.b25*m.b37 - 96*m.b10*m.b25*m.b38 - 64*m.b10*m.b25*m.b39 - 608*m.b10*m.b26*m.b27 - 576*m.b10*
m.b26*m.b28 - 544*m.b10*m.b26*m.b29 - 512*m.b10*m.b26*m.b30 - 480*m.b10*m.b26*m.b31 - 416*m.b10*
m.b26*m.b32 - 352*m.b10*m.b26*m.b33 - 288*m.b10*m.b26*m.b34 - 224*m.b10*m.b26*m.b35 - 160*m.b10*
m.b26*m.b36 - 128*m.b10*m.b26*m.b37 - 96*m.b10*m.b26*m.b38 - 64*m.b10*m.b26*m.b39 - 32*m.b10*
m.b26*m.b40 - 608*m.b10*m.b27*m.b28 - 576*m.b10*m.b27*m.b29 - 544*m.b10*m.b27*m.b30 - 512*m.b10*
m.b27*m.b31 - 448*m.b10*m.b27*m.b32 - 384*m.b10*m.b27*m.b33 - 320*m.b10*m.b27*m.b34 - 256*m.b10*
m.b27*m.b35 - 192*m.b10*m.b27*m.b36 - 128*m.b10*m.b27*m.b37 - 96*m.b10*m.b27*m.b38 - 64*m.b10*
m.b27*m.b39 - 32*m.b10*m.b27*m.b40 - 608*m.b10*m.b28*m.b29 - 576*m.b10*m.b28*m.b30 - 544*m.b10*
m.b28*m.b31 - 480*m.b10*m.b28*m.b32 - 416*m.b10*m.b28*m.b33 - 352*m.b10*m.b28*m.b34 - 288*m.b10*
m.b28*m.b35 - 224*m.b10*m.b28*m.b36 - 160*m.b10*m.b28*m.b37 - 96*m.b10*m.b28*m.b38 - 64*m.b10*
m.b28*m.b39 - 32*m.b10*m.b28*m.b40 - 608*m.b10*m.b29*m.b30 - 576*m.b10*m.b29*m.b31 - 512*m.b10*
m.b29*m.b32 - 448*m.b10*m.b29*m.b33 - 384*m.b10*m.b29*m.b34 - 320*m.b10*m.b29*m.b35 - 256*m.b10*
m.b29*m.b36 - 192*m.b10*m.b29*m.b37 - 128*m.b10*m.b29*m.b38 - 64*m.b10*m.b29*m.b39 - 32*m.b10*
m.b29*m.b40 - 608*m.b10*m.b30*m.b31 - 544*m.b10*m.b30*m.b32 - 480*m.b10*m.b30*m.b33 - 416*m.b10*
m.b30*m.b34 - 352*m.b10*m.b30*m.b35 - 288*m.b10*m.b30*m.b36 - 224*m.b10*m.b30*m.b37 - 160*m.b10*
m.b30*m.b38 - 96*m.b10*m.b30*m.b39 - 32*m.b10*m.b30*m.b40 - 576*m.b10*m.b31*m.b32 - 512*m.b10*
m.b31*m.b33 - 448*m.b10*m.b31*m.b34 - 384*m.b10*m.b31*m.b35 - 320*m.b10*m.b31*m.b36 - 256*m.b10*
m.b31*m.b37 - 192*m.b10*m.b31*m.b38 - 128*m.b10*m.b31*m.b39 - 64*m.b10*m.b31*m.b40 - 512*m.b10*
m.b32*m.b33 - 448*m.b10*m.b32*m.b34 - 384*m.b10*m.b32*m.b35 - 320*m.b10*m.b32*m.b36 - 256*m.b10*
m.b32*m.b37 - 192*m.b10*m.b32*m.b38 - 128*m.b10*m.b32*m.b39 - 64*m.b10*m.b32*m.b40 - 448*m.b10*
m.b33*m.b34 - 384*m.b10*m.b33*m.b35 - 320*m.b10*m.b33*m.b36 - 256*m.b10*m.b33*m.b37 - 192*m.b10*
m.b33*m.b38 - 128*m.b10*m.b33*m.b39 - 64*m.b10*m.b33*m.b40 - 384*m.b10*m.b34*m.b35 - 320*m.b10*
m.b34*m.b36 - 256*m.b10*m.b34*m.b37 - 192*m.b10*m.b34*m.b38 - 128*m.b10*m.b34*m.b39 - 64*m.b10*
m.b34*m.b40 - 320*m.b10*m.b35*m.b36 - 256*m.b10*m.b35*m.b37 - 192*m.b10*m.b35*m.b38 - 128*m.b10*
m.b35*m.b39 - 64*m.b10*m.b35*m.b40 - 256*m.b10*m.b36*m.b37 - 192*m.b10*m.b36*m.b38 - 128*m.b10*
m.b36*m.b39 - 64*m.b10*m.b36*m.b40 - 192*m.b10*m.b37*m.b38 - 128*m.b10*m.b37*m.b39 - 64*m.b10*
m.b37*m.b40 - 128*m.b10*m.b38*m.b39 - 64*m.b10*m.b38*m.b40 - 64*m.b10*m.b39*m.b40 - 64*m.b11*
m.b12*m.b13 - 96*m.b11*m.b12*m.b14 - 96*m.b11*m.b12*m.b15 - 96*m.b11*m.b12*m.b16 - 96*m.b11*m.b12
*m.b17 - 96*m.b11*m.b12*m.b18 - 96*m.b11*m.b12*m.b19 - 160*m.b11*m.b12*m.b20 - 128*m.b11*m.b12*
m.b21 - 96*m.b11*m.b12*m.b22 - 64*m.b11*m.b12*m.b23 - 64*m.b11*m.b12*m.b24 - 64*m.b11*m.b12*m.b25
- 384*m.b11*m.b12*m.b26 - 704*m.b11*m.b12*m.b27 - 704*m.b11*m.b12*m.b28 - 704*m.b11*m.b12*m.b29
- 672*m.b11*m.b12*m.b30 - 608*m.b11*m.b12*m.b31 - 544*m.b11*m.b12*m.b32 - 480*m.b11*m.b12*m.b33
- 416*m.b11*m.b12*m.b34 - 352*m.b11*m.b12*m.b35 - 288*m.b11*m.b12*m.b36 - 224*m.b11*m.b12*m.b37
- 160*m.b11*m.b12*m.b38 - 96*m.b11*m.b12*m.b39 - 32*m.b11*m.b12*m.b40 - 96*m.b11*m.b13*m.b14 -
64*m.b11*m.b13*m.b15 - 96*m.b11*m.b13*m.b16 - 96*m.b11*m.b13*m.b17 - 96*m.b11*m.b13*m.b18 - 96*
m.b11*m.b13*m.b19 - 192*m.b11*m.b13*m.b20 - 160*m.b11*m.b13*m.b21 - 128*m.b11*m.b13*m.b22 - 96*
m.b11*m.b13*m.b23 - 64*m.b11*m.b13*m.b24 - 384*m.b11*m.b13*m.b25 - 384*m.b11*m.b13*m.b26 - 704*
m.b11*m.b13*m.b27 - 704*m.b11*m.b13*m.b28 - 672*m.b11*m.b13*m.b29 - 640*m.b11*m.b13*m.b30 - 576*
m.b11*m.b13*m.b31 - 512*m.b11*m.b13*m.b32 - 448*m.b11*m.b13*m.b33 - 384*m.b11*m.b13*m.b34 - 320*
m.b11*m.b13*m.b35 - 256*m.b11*m.b13*m.b36 - 192*m.b11*m.b13*m.b37 - 128*m.b11*m.b13*m.b38 - 64*
m.b11*m.b13*m.b39 - 32*m.b11*m.b13*m.b40 - 96*m.b11*m.b14*m.b15 - 96*m.b11*m.b14*m.b16 - 64*m.b11
*m.b14*m.b17 - 96*m.b11*m.b14*m.b18 - 96*m.b11*m.b14*m.b19 - 96*m.b11*m.b14*m.b20 - 192*m.b11*
m.b14*m.b21 - 160*m.b11*m.b14*m.b22 - 128*m.b11*m.b14*m.b23 - 416*m.b11*m.b14*m.b24 - 384*m.b11*
m.b14*m.b25 - 384*m.b11*m.b14*m.b26 - 704*m.b11*m.b14*m.b27 - 672*m.b11*m.b14*m.b28 - 640*m.b11*
m.b14*m.b29 - 608*m.b11*m.b14*m.b30 - 544*m.b11*m.b14*m.b31 - 480*m.b11*m.b14*m.b32 - 416*m.b11*
m.b14*m.b33 - 352*m.b11*m.b14*m.b34 - 288*m.b11*m.b14*m.b35 - 224*m.b11*m.b14*m.b36 - 160*m.b11*
m.b14*m.b37 - 96*m.b11*m.b14*m.b38 - 64*m.b11*m.b14*m.b39 - 32*m.b11*m.b14*m.b40 - 96*m.b11*m.b15
*m.b16 - 96*m.b11*m.b15*m.b17 - 96*m.b11*m.b15*m.b18 - 64*m.b11*m.b15*m.b19 - 96*m.b11*m.b15*
m.b20 - 224*m.b11*m.b15*m.b21 - 192*m.b11*m.b15*m.b22 - 480*m.b11*m.b15*m.b23 - 448*m.b11*m.b15*
m.b24 - 416*m.b11*m.b15*m.b25 - 384*m.b11*m.b15*m.b26 - 672*m.b11*m.b15*m.b27 - 640*m.b11*m.b15*
m.b28 - 608*m.b11*m.b15*m.b29 - 576*m.b11*m.b15*m.b30 - 512*m.b11*m.b15*m.b31 - 448*m.b11*m.b15*
m.b32 - 384*m.b11*m.b15*m.b33 - 320*m.b11*m.b15*m.b34 - 256*m.b11*m.b15*m.b35 - 192*m.b11*m.b15*
m.b36 - 128*m.b11*m.b15*m.b37 - 96*m.b11*m.b15*m.b38 - 64*m.b11*m.b15*m.b39 - 32*m.b11*m.b15*
m.b40 - 96*m.b11*m.b16*m.b17 - 96*m.b11*m.b16*m.b18 - 96*m.b11*m.b16*m.b19 - 96*m.b11*m.b16*m.b20
- 64*m.b11*m.b16*m.b21 - 544*m.b11*m.b16*m.b22 - 512*m.b11*m.b16*m.b23 - 480*m.b11*m.b16*m.b24
- 448*m.b11*m.b16*m.b25 - 384*m.b11*m.b16*m.b26 - 640*m.b11*m.b16*m.b27 - 608*m.b11*m.b16*m.b28
- 576*m.b11*m.b16*m.b29 - 544*m.b11*m.b16*m.b30 - 480*m.b11*m.b16*m.b31 - 416*m.b11*m.b16*m.b32
- 352*m.b11*m.b16*m.b33 - 288*m.b11*m.b16*m.b34 - 224*m.b11*m.b16*m.b35 - 160*m.b11*m.b16*m.b36
- 128*m.b11*m.b16*m.b37 - 96*m.b11*m.b16*m.b38 - 64*m.b11*m.b16*m.b39 - 32*m.b11*m.b16*m.b40 -
96*m.b11*m.b17*m.b18 - 96*m.b11*m.b17*m.b19 - 96*m.b11*m.b17*m.b20 - 416*m.b11*m.b17*m.b21 - 576*
m.b11*m.b17*m.b22 - 512*m.b11*m.b17*m.b23 - 512*m.b11*m.b17*m.b24 - 448*m.b11*m.b17*m.b25 - 384*
m.b11*m.b17*m.b26 - 640*m.b11*m.b17*m.b27 - 576*m.b11*m.b17*m.b28 - 544*m.b11*m.b17*m.b29 - 512*
m.b11*m.b17*m.b30 - 448*m.b11*m.b17*m.b31 - 384*m.b11*m.b17*m.b32 - 320*m.b11*m.b17*m.b33 - 256*
m.b11*m.b17*m.b34 - 192*m.b11*m.b17*m.b35 - 160*m.b11*m.b17*m.b36 - 128*m.b11*m.b17*m.b37 - 96*
m.b11*m.b17*m.b38 - 64*m.b11*m.b17*m.b39 - 32*m.b11*m.b17*m.b40 - 96*m.b11*m.b18*m.b19 - 416*
m.b11*m.b18*m.b20 - 416*m.b11*m.b18*m.b21 - 416*m.b11*m.b18*m.b22 - 576*m.b11*m.b18*m.b23 - 512*
m.b11*m.b18*m.b24 - 416*m.b11*m.b18*m.b25 - 384*m.b11*m.b18*m.b26 - 640*m.b11*m.b18*m.b27 - 576*
m.b11*m.b18*m.b28 - 512*m.b11*m.b18*m.b29 - 480*m.b11*m.b18*m.b30 - 416*m.b11*m.b18*m.b31 - 352*
m.b11*m.b18*m.b32 - 288*m.b11*m.b18*m.b33 - 224*m.b11*m.b18*m.b34 - 192*m.b11*m.b18*m.b35 - 160*
m.b11*m.b18*m.b36 - 128*m.b11*m.b18*m.b37 - 96*m.b11*m.b18*m.b38 - 64*m.b11*m.b18*m.b39 - 32*
m.b11*m.b18*m.b40 - 416*m.b11*m.b19*m.b20 - 416*m.b11*m.b19*m.b21 - 416*m.b11*m.b19*m.b22 - 576*
m.b11*m.b19*m.b23 - 512*m.b11*m.b19*m.b24 - 448*m.b11*m.b19*m.b25 - 384*m.b11*m.b19*m.b26 - 288*
m.b11*m.b19*m.b27 - 576*m.b11*m.b19*m.b28 - 512*m.b11*m.b19*m.b29 - 448*m.b11*m.b19*m.b30 - 384*
m.b11*m.b19*m.b31 - 320*m.b11*m.b19*m.b32 - 256*m.b11*m.b19*m.b33 - 224*m.b11*m.b19*m.b34 - 192*
m.b11*m.b19*m.b35 - 160*m.b11*m.b19*m.b36 - 128*m.b11*m.b19*m.b37 - 96*m.b11*m.b19*m.b38 - 64*
m.b11*m.b19*m.b39 - 32*m.b11*m.b19*m.b40 - 416*m.b11*m.b20*m.b21 - 384*m.b11*m.b20*m.b22 - 352*
m.b11*m.b20*m.b23 - 512*m.b11*m.b20*m.b24 - 448*m.b11*m.b20*m.b25 - 384*m.b11*m.b20*m.b26 - 640*
m.b11*m.b20*m.b27 - 576*m.b11*m.b20*m.b28 - 160*m.b11*m.b20*m.b29 - 448*m.b11*m.b20*m.b30 - 352*
m.b11*m.b20*m.b31 - 288*m.b11*m.b20*m.b32 - 256*m.b11*m.b20*m.b33 - 224*m.b11*m.b20*m.b34 - 192*
m.b11*m.b20*m.b35 - 160*m.b11*m.b20*m.b36 - 128*m.b11*m.b20*m.b37 - 96*m.b11*m.b20*m.b38 - 64*
m.b11*m.b20*m.b39 - 32*m.b11*m.b20*m.b40 - 352*m.b11*m.b21*m.b22 - 320*m.b11*m.b21*m.b23 - 512*
m.b11*m.b21*m.b24 - 448*m.b11*m.b21*m.b25 - 384*m.b11*m.b21*m.b26 - 640*m.b11*m.b21*m.b27 - 576*
m.b11*m.b21*m.b28 - 512*m.b11*m.b21*m.b29 - 448*m.b11*m.b21*m.b30 - 32*m.b11*m.b21*m.b31 - 288*
m.b11*m.b21*m.b32 - 256*m.b11*m.b21*m.b33 - 224*m.b11*m.b21*m.b34 - 192*m.b11*m.b21*m.b35 - 160*
m.b11*m.b21*m.b36 - 128*m.b11*m.b21*m.b37 - 96*m.b11*m.b21*m.b38 - 64*m.b11*m.b21*m.b39 - 32*
m.b11*m.b21*m.b40 - 288*m.b11*m.b22*m.b23 - 256*m.b11*m.b22*m.b24 - 448*m.b11*m.b22*m.b25 - 384*
m.b11*m.b22*m.b26 - 640*m.b11*m.b22*m.b27 - 576*m.b11*m.b22*m.b28 - 512*m.b11*m.b22*m.b29 - 448*
m.b11*m.b22*m.b30 - 384*m.b11*m.b22*m.b31 - 320*m.b11*m.b22*m.b32 - 224*m.b11*m.b22*m.b34 - 192*
m.b11*m.b22*m.b35 - 160*m.b11*m.b22*m.b36 - 128*m.b11*m.b22*m.b37 - 96*m.b11*m.b22*m.b38 - 64*
m.b11*m.b22*m.b39 - 32*m.b11*m.b22*m.b40 - 224*m.b11*m.b23*m.b24 - 448*m.b11*m.b23*m.b25 - 384*
m.b11*m.b23*m.b26 - 640*m.b11*m.b23*m.b27 - 576*m.b11*m.b23*m.b28 - 512*m.b11*m.b23*m.b29 - 480*
m.b11*m.b23*m.b30 - 416*m.b11*m.b23*m.b31 - 352*m.b11*m.b23*m.b32 - 288*m.b11*m.b23*m.b33 - 224*
m.b11*m.b23*m.b34 - 160*m.b11*m.b23*m.b36 - 128*m.b11*m.b23*m.b37 - 96*m.b11*m.b23*m.b38 - 64*
m.b11*m.b23*m.b39 - 32*m.b11*m.b23*m.b40 - 160*m.b11*m.b24*m.b25 - 384*m.b11*m.b24*m.b26 - 640*
m.b11*m.b24*m.b27 - 576*m.b11*m.b24*m.b28 - 544*m.b11*m.b24*m.b29 - 512*m.b11*m.b24*m.b30 - 448*
m.b11*m.b24*m.b31 - 384*m.b11*m.b24*m.b32 - 320*m.b11*m.b24*m.b33 - 256*m.b11*m.b24*m.b34 - 192*
m.b11*m.b24*m.b35 - 160*m.b11*m.b24*m.b36 - 96*m.b11*m.b24*m.b38 - 64*m.b11*m.b24*m.b39 - 32*
m.b11*m.b24*m.b40 - 384*m.b11*m.b25*m.b26 - 640*m.b11*m.b25*m.b27 - 608*m.b11*m.b25*m.b28 - 576*
m.b11*m.b25*m.b29 - 544*m.b11*m.b25*m.b30 - 480*m.b11*m.b25*m.b31 - 416*m.b11*m.b25*m.b32 - 352*
m.b11*m.b25*m.b33 - 288*m.b11*m.b25*m.b34 - 224*m.b11*m.b25*m.b35 - 160*m.b11*m.b25*m.b36 - 128*
m.b11*m.b25*m.b37 - 96*m.b11*m.b25*m.b38 - 32*m.b11*m.b25*m.b40 - 672*m.b11*m.b26*m.b27 - 640*
m.b11*m.b26*m.b28 - 608*m.b11*m.b26*m.b29 - 576*m.b11*m.b26*m.b30 - 512*m.b11*m.b26*m.b31 - 448*
m.b11*m.b26*m.b32 - 384*m.b11*m.b26*m.b33 - 320*m.b11*m.b26*m.b34 - 256*m.b11*m.b26*m.b35 - 192*
m.b11*m.b26*m.b36 - 128*m.b11*m.b26*m.b37 - 96*m.b11*m.b26*m.b38 - 64*m.b11*m.b26*m.b39 - 32*
m.b11*m.b26*m.b40 - 672*m.b11*m.b27*m.b28 - 640*m.b11*m.b27*m.b29 - 608*m.b11*m.b27*m.b30 - 544*
m.b11*m.b27*m.b31 - 480*m.b11*m.b27*m.b32 - 416*m.b11*m.b27*m.b33 - 352*m.b11*m.b27*m.b34 - 288*
m.b11*m.b27*m.b35 - 224*m.b11*m.b27*m.b36 - 160*m.b11*m.b27*m.b37 - 96*m.b11*m.b27*m.b38 - 64*
m.b11*m.b27*m.b39 - 32*m.b11*m.b27*m.b40 - 672*m.b11*m.b28*m.b29 - 640*m.b11*m.b28*m.b30 - 576*
m.b11*m.b28*m.b31 - 512*m.b11*m.b28*m.b32 - 448*m.b11*m.b28*m.b33 - 384*m.b11*m.b28*m.b34 - 320*
m.b11*m.b28*m.b35 - 256*m.b11*m.b28*m.b36 - 192*m.b11*m.b28*m.b37 - 128*m.b11*m.b28*m.b38 - 64*
m.b11*m.b28*m.b39 - 32*m.b11*m.b28*m.b40 - 672*m.b11*m.b29*m.b30 - 608*m.b11*m.b29*m.b31 - 544*
m.b11*m.b29*m.b32 - 480*m.b11*m.b29*m.b33 - 416*m.b11*m.b29*m.b34 - 352*m.b11*m.b29*m.b35 - 288*
m.b11*m.b29*m.b36 - 224*m.b11*m.b29*m.b37 - 160*m.b11*m.b29*m.b38 - 96*m.b11*m.b29*m.b39 - 32*
m.b11*m.b29*m.b40 - 640*m.b11*m.b30*m.b31 - 576*m.b11*m.b30*m.b32 - 512*m.b11*m.b30*m.b33 - 448*
m.b11*m.b30*m.b34 - 384*m.b11*m.b30*m.b35 - 320*m.b11*m.b30*m.b36 - 256*m.b11*m.b30*m.b37 - 192*
m.b11*m.b30*m.b38 - 128*m.b11*m.b30*m.b39 - 64*m.b11*m.b30*m.b40 - 576*m.b11*m.b31*m.b32 - 512*
m.b11*m.b31*m.b33 - 448*m.b11*m.b31*m.b34 - 384*m.b11*m.b31*m.b35 - 320*m.b11*m.b31*m.b36 - 256*
m.b11*m.b31*m.b37 - 192*m.b11*m.b31*m.b38 - 128*m.b11*m.b31*m.b39 - 64*m.b11*m.b31*m.b40 - 512*
m.b11*m.b32*m.b33 - 448*m.b11*m.b32*m.b34 - 384*m.b11*m.b32*m.b35 - 320*m.b11*m.b32*m.b36 - 256*
m.b11*m.b32*m.b37 - 192*m.b11*m.b32*m.b38 - 128*m.b11*m.b32*m.b39 - 64*m.b11*m.b32*m.b40 - 448*
m.b11*m.b33*m.b34 - 384*m.b11*m.b33*m.b35 - 320*m.b11*m.b33*m.b36 - 256*m.b11*m.b33*m.b37 - 192*
m.b11*m.b33*m.b38 - 128*m.b11*m.b33*m.b39 - 64*m.b11*m.b33*m.b40 - 384*m.b11*m.b34*m.b35 - 320*
m.b11*m.b34*m.b36 - 256*m.b11*m.b34*m.b37 - 192*m.b11*m.b34*m.b38 - 128*m.b11*m.b34*m.b39 - 64*
m.b11*m.b34*m.b40 - 320*m.b11*m.b35*m.b36 - 256*m.b11*m.b35*m.b37 - 192*m.b11*m.b35*m.b38 - 128*
m.b11*m.b35*m.b39 - 64*m.b11*m.b35*m.b40 - 256*m.b11*m.b36*m.b37 - 192*m.b11*m.b36*m.b38 - 128*
m.b11*m.b36*m.b39 - 64*m.b11*m.b36*m.b40 - 192*m.b11*m.b37*m.b38 - 128*m.b11*m.b37*m.b39 - 64*
m.b11*m.b37*m.b40 - 128*m.b11*m.b38*m.b39 - 64*m.b11*m.b38*m.b40 - 64*m.b11*m.b39*m.b40 - 64*
m.b12*m.b13*m.b14 - 96*m.b12*m.b13*m.b15 - 96*m.b12*m.b13*m.b16 - 96*m.b12*m.b13*m.b17 - 96*m.b12
*m.b13*m.b18 - 96*m.b12*m.b13*m.b19 - 96*m.b12*m.b13*m.b20 - 192*m.b12*m.b13*m.b21 - 160*m.b12*
m.b13*m.b22 - 128*m.b12*m.b13*m.b23 - 96*m.b12*m.b13*m.b24 - 64*m.b12*m.b13*m.b25 - 64*m.b12*
m.b13*m.b26 - 416*m.b12*m.b13*m.b27 - 768*m.b12*m.b13*m.b28 - 736*m.b12*m.b13*m.b29 - 672*m.b12*
m.b13*m.b30 - 608*m.b12*m.b13*m.b31 - 544*m.b12*m.b13*m.b32 - 480*m.b12*m.b13*m.b33 - 416*m.b12*
m.b13*m.b34 - 352*m.b12*m.b13*m.b35 - 288*m.b12*m.b13*m.b36 - 224*m.b12*m.b13*m.b37 - 160*m.b12*
m.b13*m.b38 - 96*m.b12*m.b13*m.b39 - 32*m.b12*m.b13*m.b40 - 96*m.b12*m.b14*m.b15 - 64*m.b12*m.b14
*m.b16 - 96*m.b12*m.b14*m.b17 - 96*m.b12*m.b14*m.b18 - 96*m.b12*m.b14*m.b19 - 96*m.b12*m.b14*
m.b20 - 224*m.b12*m.b14*m.b21 - 192*m.b12*m.b14*m.b22 - 160*m.b12*m.b14*m.b23 - 128*m.b12*m.b14*
m.b24 - 96*m.b12*m.b14*m.b25 - 416*m.b12*m.b14*m.b26 - 416*m.b12*m.b14*m.b27 - 736*m.b12*m.b14*
m.b28 - 704*m.b12*m.b14*m.b29 - 640*m.b12*m.b14*m.b30 - 576*m.b12*m.b14*m.b31 - 512*m.b12*m.b14*
m.b32 - 448*m.b12*m.b14*m.b33 - 384*m.b12*m.b14*m.b34 - 320*m.b12*m.b14*m.b35 - 256*m.b12*m.b14*
m.b36 - 192*m.b12*m.b14*m.b37 - 128*m.b12*m.b14*m.b38 - 64*m.b12*m.b14*m.b39 - 32*m.b12*m.b14*
m.b40 - 96*m.b12*m.b15*m.b16 - 96*m.b12*m.b15*m.b17 - 64*m.b12*m.b15*m.b18 - 96*m.b12*m.b15*m.b19
- 96*m.b12*m.b15*m.b20 - 96*m.b12*m.b15*m.b21 - 224*m.b12*m.b15*m.b22 - 192*m.b12*m.b15*m.b23 -
160*m.b12*m.b15*m.b24 - 480*m.b12*m.b15*m.b25 - 448*m.b12*m.b15*m.b26 - 384*m.b12*m.b15*m.b27 -
704*m.b12*m.b15*m.b28 - 672*m.b12*m.b15*m.b29 - 608*m.b12*m.b15*m.b30 - 544*m.b12*m.b15*m.b31 -
480*m.b12*m.b15*m.b32 - 416*m.b12*m.b15*m.b33 - 352*m.b12*m.b15*m.b34 - 288*m.b12*m.b15*m.b35 -
224*m.b12*m.b15*m.b36 - 160*m.b12*m.b15*m.b37 - 96*m.b12*m.b15*m.b38 - 64*m.b12*m.b15*m.b39 - 32*
m.b12*m.b15*m.b40 - 96*m.b12*m.b16*m.b17 - 96*m.b12*m.b16*m.b18 - 96*m.b12*m.b16*m.b19 - 64*m.b12
*m.b16*m.b20 - 96*m.b12*m.b16*m.b21 - 256*m.b12*m.b16*m.b22 - 224*m.b12*m.b16*m.b23 - 544*m.b12*
m.b16*m.b24 - 512*m.b12*m.b16*m.b25 - 448*m.b12*m.b16*m.b26 - 384*m.b12*m.b16*m.b27 - 672*m.b12*
m.b16*m.b28 - 640*m.b12*m.b16*m.b29 - 576*m.b12*m.b16*m.b30 - 512*m.b12*m.b16*m.b31 - 448*m.b12*
m.b16*m.b32 - 384*m.b12*m.b16*m.b33 - 320*m.b12*m.b16*m.b34 - 256*m.b12*m.b16*m.b35 - 192*m.b12*
m.b16*m.b36 - 128*m.b12*m.b16*m.b37 - 96*m.b12*m.b16*m.b38 - 64*m.b12*m.b16*m.b39 - 32*m.b12*
m.b16*m.b40 - 96*m.b12*m.b17*m.b18 - 96*m.b12*m.b17*m.b19 - 96*m.b12*m.b17*m.b20 - 96*m.b12*m.b17
*m.b21 - 64*m.b12*m.b17*m.b22 - 608*m.b12*m.b17*m.b23 - 576*m.b12*m.b17*m.b24 - 512*m.b12*m.b17*
m.b25 - 448*m.b12*m.b17*m.b26 - 384*m.b12*m.b17*m.b27 - 672*m.b12*m.b17*m.b28 - 608*m.b12*m.b17*
m.b29 - 544*m.b12*m.b17*m.b30 - 480*m.b12*m.b17*m.b31 - 416*m.b12*m.b17*m.b32 - 352*m.b12*m.b17*
m.b33 - 288*m.b12*m.b17*m.b34 - 224*m.b12*m.b17*m.b35 - 160*m.b12*m.b17*m.b36 - 128*m.b12*m.b17*
m.b37 - 96*m.b12*m.b17*m.b38 - 64*m.b12*m.b17*m.b39 - 32*m.b12*m.b17*m.b40 - 96*m.b12*m.b18*m.b19
- 96*m.b12*m.b18*m.b20 - 96*m.b12*m.b18*m.b21 - 448*m.b12*m.b18*m.b22 - 640*m.b12*m.b18*m.b23 -
544*m.b12*m.b18*m.b24 - 512*m.b12*m.b18*m.b25 - 448*m.b12*m.b18*m.b26 - 384*m.b12*m.b18*m.b27 -
672*m.b12*m.b18*m.b28 - 608*m.b12*m.b18*m.b29 - 512*m.b12*m.b18*m.b30 - 448*m.b12*m.b18*m.b31 -
384*m.b12*m.b18*m.b32 - 320*m.b12*m.b18*m.b33 - 256*m.b12*m.b18*m.b34 - 192*m.b12*m.b18*m.b35 -
160*m.b12*m.b18*m.b36 - 128*m.b12*m.b18*m.b37 - 96*m.b12*m.b18*m.b38 - 64*m.b12*m.b18*m.b39 - 32*
m.b12*m.b18*m.b40 - 96*m.b12*m.b19*m.b20 - 448*m.b12*m.b19*m.b21 - 448*m.b12*m.b19*m.b22 - 416*
m.b12*m.b19*m.b23 - 576*m.b12*m.b19*m.b24 - 512*m.b12*m.b19*m.b25 - 416*m.b12*m.b19*m.b26 - 384*
m.b12*m.b19*m.b27 - 672*m.b12*m.b19*m.b28 - 608*m.b12*m.b19*m.b29 - 512*m.b12*m.b19*m.b30 - 416*
m.b12*m.b19*m.b31 - 352*m.b12*m.b19*m.b32 - 288*m.b12*m.b19*m.b33 - 224*m.b12*m.b19*m.b34 - 192*
m.b12*m.b19*m.b35 - 160*m.b12*m.b19*m.b36 - 128*m.b12*m.b19*m.b37 - 96*m.b12*m.b19*m.b38 - 64*
m.b12*m.b19*m.b39 - 32*m.b12*m.b19*m.b40 - 448*m.b12*m.b20*m.b21 - 416*m.b12*m.b20*m.b22 - 384*
m.b12*m.b20*m.b23 - 576*m.b12*m.b20*m.b24 - 512*m.b12*m.b20*m.b25 - 448*m.b12*m.b20*m.b26 - 384*
m.b12*m.b20*m.b27 - 288*m.b12*m.b20*m.b28 - 608*m.b12*m.b20*m.b29 - 512*m.b12*m.b20*m.b30 - 416*
m.b12*m.b20*m.b31 - 320*m.b12*m.b20*m.b32 - 256*m.b12*m.b20*m.b33 - 224*m.b12*m.b20*m.b34 - 192*
m.b12*m.b20*m.b35 - 160*m.b12*m.b20*m.b36 - 128*m.b12*m.b20*m.b37 - 96*m.b12*m.b20*m.b38 - 64*
m.b12*m.b20*m.b39 - 32*m.b12*m.b20*m.b40 - 384*m.b12*m.b21*m.b22 - 352*m.b12*m.b21*m.b23 - 320*
m.b12*m.b21*m.b24 - 512*m.b12*m.b21*m.b25 - 448*m.b12*m.b21*m.b26 - 384*m.b12*m.b21*m.b27 - 672*
m.b12*m.b21*m.b28 - 608*m.b12*m.b21*m.b29 - 160*m.b12*m.b21*m.b30 - 416*m.b12*m.b21*m.b31 - 320*
m.b12*m.b21*m.b32 - 256*m.b12*m.b21*m.b33 - 224*m.b12*m.b21*m.b34 - 192*m.b12*m.b21*m.b35 - 160*
m.b12*m.b21*m.b36 - 128*m.b12*m.b21*m.b37 - 96*m.b12*m.b21*m.b38 - 64*m.b12*m.b21*m.b39 - 32*
m.b12*m.b21*m.b40 - 320*m.b12*m.b22*m.b23 - 288*m.b12*m.b22*m.b24 - 512*m.b12*m.b22*m.b25 - 448*
m.b12*m.b22*m.b26 - 384*m.b12*m.b22*m.b27 - 672*m.b12*m.b22*m.b28 - 608*m.b12*m.b22*m.b29 - 512*
m.b12*m.b22*m.b30 - 416*m.b12*m.b22*m.b31 - 64*m.b12*m.b22*m.b32 - 288*m.b12*m.b22*m.b33 - 224*
m.b12*m.b22*m.b34 - 192*m.b12*m.b22*m.b35 - 160*m.b12*m.b22*m.b36 - 128*m.b12*m.b22*m.b37 - 96*
m.b12*m.b22*m.b38 - 64*m.b12*m.b22*m.b39 - 32*m.b12*m.b22*m.b40 - 256*m.b12*m.b23*m.b24 - 224*
m.b12*m.b23*m.b25 - 448*m.b12*m.b23*m.b26 - 384*m.b12*m.b23*m.b27 - 672*m.b12*m.b23*m.b28 - 608*
m.b12*m.b23*m.b29 - 512*m.b12*m.b23*m.b30 - 448*m.b12*m.b23*m.b31 - 384*m.b12*m.b23*m.b32 - 320*
m.b12*m.b23*m.b33 - 32*m.b12*m.b23*m.b34 - 192*m.b12*m.b23*m.b35 - 160*m.b12*m.b23*m.b36 - 128*
m.b12*m.b23*m.b37 - 96*m.b12*m.b23*m.b38 - 64*m.b12*m.b23*m.b39 - 32*m.b12*m.b23*m.b40 - 192*
m.b12*m.b24*m.b25 - 448*m.b12*m.b24*m.b26 - 384*m.b12*m.b24*m.b27 - 672*m.b12*m.b24*m.b28 - 608*
m.b12*m.b24*m.b29 - 544*m.b12*m.b24*m.b30 - 480*m.b12*m.b24*m.b31 - 416*m.b12*m.b24*m.b32 - 352*
m.b12*m.b24*m.b33 - 288*m.b12*m.b24*m.b34 - 224*m.b12*m.b24*m.b35 - 128*m.b12*m.b24*m.b37 - 96*
m.b12*m.b24*m.b38 - 64*m.b12*m.b24*m.b39 - 32*m.b12*m.b24*m.b40 - 128*m.b12*m.b25*m.b26 - 384*
m.b12*m.b25*m.b27 - 672*m.b12*m.b25*m.b28 - 640*m.b12*m.b25*m.b29 - 576*m.b12*m.b25*m.b30 - 512*
m.b12*m.b25*m.b31 - 448*m.b12*m.b25*m.b32 - 384*m.b12*m.b25*m.b33 - 320*m.b12*m.b25*m.b34 - 256*
m.b12*m.b25*m.b35 - 192*m.b12*m.b25*m.b36 - 128*m.b12*m.b25*m.b37 - 64*m.b12*m.b25*m.b39 - 32*
m.b12*m.b25*m.b40 - 384*m.b12*m.b26*m.b27 - 704*m.b12*m.b26*m.b28 - 672*m.b12*m.b26*m.b29 - 608*
m.b12*m.b26*m.b30 - 544*m.b12*m.b26*m.b31 - 480*m.b12*m.b26*m.b32 - 416*m.b12*m.b26*m.b33 - 352*
m.b12*m.b26*m.b34 - 288*m.b12*m.b26*m.b35 - 224*m.b12*m.b26*m.b36 - 160*m.b12*m.b26*m.b37 - 96*
m.b12*m.b26*m.b38 - 64*m.b12*m.b26*m.b39 - 736*m.b12*m.b27*m.b28 - 704*m.b12*m.b27*m.b29 - 640*
m.b12*m.b27*m.b30 - 576*m.b12*m.b27*m.b31 - 512*m.b12*m.b27*m.b32 - 448*m.b12*m.b27*m.b33 - 384*
m.b12*m.b27*m.b34 - 320*m.b12*m.b27*m.b35 - 256*m.b12*m.b27*m.b36 - 192*m.b12*m.b27*m.b37 - 128*
m.b12*m.b27*m.b38 - 64*m.b12*m.b27*m.b39 - 32*m.b12*m.b27*m.b40 - 736*m.b12*m.b28*m.b29 - 672*
m.b12*m.b28*m.b30 - 608*m.b12*m.b28*m.b31 - 544*m.b12*m.b28*m.b32 - 480*m.b12*m.b28*m.b33 - 416*
m.b12*m.b28*m.b34 - 352*m.b12*m.b28*m.b35 - 288*m.b12*m.b28*m.b36 - 224*m.b12*m.b28*m.b37 - 160*
m.b12*m.b28*m.b38 - 96*m.b12*m.b28*m.b39 - 32*m.b12*m.b28*m.b40 - 704*m.b12*m.b29*m.b30 - 640*
m.b12*m.b29*m.b31 - 576*m.b12*m.b29*m.b32 - 512*m.b12*m.b29*m.b33 - 448*m.b12*m.b29*m.b34 - 384*
m.b12*m.b29*m.b35 - 320*m.b12*m.b29*m.b36 - 256*m.b12*m.b29*m.b37 - 192*m.b12*m.b29*m.b38 - 128*
m.b12*m.b29*m.b39 - 64*m.b12*m.b29*m.b40 - 640*m.b12*m.b30*m.b31 - 576*m.b12*m.b30*m.b32 - 512*
m.b12*m.b30*m.b33 - 448*m.b12*m.b30*m.b34 - 384*m.b12*m.b30*m.b35 - 320*m.b12*m.b30*m.b36 - 256*
m.b12*m.b30*m.b37 - 192*m.b12*m.b30*m.b38 - 128*m.b12*m.b30*m.b39 - 64*m.b12*m.b30*m.b40 - 576*
m.b12*m.b31*m.b32 - 512*m.b12*m.b31*m.b33 - 448*m.b12*m.b31*m.b34 - 384*m.b12*m.b31*m.b35 - 320*
m.b12*m.b31*m.b36 - 256*m.b12*m.b31*m.b37 - 192*m.b12*m.b31*m.b38 - 128*m.b12*m.b31*m.b39 - 64*
m.b12*m.b31*m.b40 - 512*m.b12*m.b32*m.b33 - 448*m.b12*m.b32*m.b34 - 384*m.b12*m.b32*m.b35 - 320*
m.b12*m.b32*m.b36 - 256*m.b12*m.b32*m.b37 - 192*m.b12*m.b32*m.b38 - 128*m.b12*m.b32*m.b39 - 64*
m.b12*m.b32*m.b40 - 448*m.b12*m.b33*m.b34 - 384*m.b12*m.b33*m.b35 - 320*m.b12*m.b33*m.b36 - 256*
m.b12*m.b33*m.b37 - 192*m.b12*m.b33*m.b38 - 128*m.b12*m.b33*m.b39 - 64*m.b12*m.b33*m.b40 - 384*
m.b12*m.b34*m.b35 - 320*m.b12*m.b34*m.b36 - 256*m.b12*m.b34*m.b37 - 192*m.b12*m.b34*m.b38 - 128*
m.b12*m.b34*m.b39 - 64*m.b12*m.b34*m.b40 - 320*m.b12*m.b35*m.b36 - 256*m.b12*m.b35*m.b37 - 192*
m.b12*m.b35*m.b38 - 128*m.b12*m.b35*m.b39 - 64*m.b12*m.b35*m.b40 - 256*m.b12*m.b36*m.b37 - 192*
m.b12*m.b36*m.b38 - 128*m.b12*m.b36*m.b39 - 64*m.b12*m.b36*m.b40 - 192*m.b12*m.b37*m.b38 - 128*
m.b12*m.b37*m.b39 - 64*m.b12*m.b37*m.b40 - 128*m.b12*m.b38*m.b39 - 64*m.b12*m.b38*m.b40 - 64*
m.b12*m.b39*m.b40 - 64*m.b13*m.b14*m.b15 - 96*m.b13*m.b14*m.b16 - 96*m.b13*m.b14*m.b17 - 96*m.b13
*m.b14*m.b18 - 96*m.b13*m.b14*m.b19 - 96*m.b13*m.b14*m.b20 - 96*m.b13*m.b14*m.b21 - 224*m.b13*
m.b14*m.b22 - 192*m.b13*m.b14*m.b23 - 160*m.b13*m.b14*m.b24 - 128*m.b13*m.b14*m.b25 - 96*m.b13*
m.b14*m.b26 - 64*m.b13*m.b14*m.b27 - 416*m.b13*m.b14*m.b28 - 736*m.b13*m.b14*m.b29 - 672*m.b13*
m.b14*m.b30 - 608*m.b13*m.b14*m.b31 - 544*m.b13*m.b14*m.b32 - 480*m.b13*m.b14*m.b33 - 416*m.b13*
m.b14*m.b34 - 352*m.b13*m.b14*m.b35 - 288*m.b13*m.b14*m.b36 - 224*m.b13*m.b14*m.b37 - 160*m.b13*
m.b14*m.b38 - 96*m.b13*m.b14*m.b39 - 32*m.b13*m.b14*m.b40 - 96*m.b13*m.b15*m.b16 - 64*m.b13*m.b15
*m.b17 - 96*m.b13*m.b15*m.b18 - 96*m.b13*m.b15*m.b19 - 96*m.b13*m.b15*m.b20 - 96*m.b13*m.b15*
m.b21 - 256*m.b13*m.b15*m.b22 - 224*m.b13*m.b15*m.b23 - 192*m.b13*m.b15*m.b24 - 160*m.b13*m.b15*
m.b25 - 128*m.b13*m.b15*m.b26 - 448*m.b13*m.b15*m.b27 - 384*m.b13*m.b15*m.b28 - 704*m.b13*m.b15*
m.b29 - 640*m.b13*m.b15*m.b30 - 576*m.b13*m.b15*m.b31 - 512*m.b13*m.b15*m.b32 - 448*m.b13*m.b15*
m.b33 - 384*m.b13*m.b15*m.b34 - 320*m.b13*m.b15*m.b35 - 256*m.b13*m.b15*m.b36 - 192*m.b13*m.b15*
m.b37 - 128*m.b13*m.b15*m.b38 - 64*m.b13*m.b15*m.b39 - 32*m.b13*m.b15*m.b40 - 96*m.b13*m.b16*
m.b17 - 96*m.b13*m.b16*m.b18 - 64*m.b13*m.b16*m.b19 - 96*m.b13*m.b16*m.b20 - 96*m.b13*m.b16*m.b21
- 96*m.b13*m.b16*m.b22 - 256*m.b13*m.b16*m.b23 - 224*m.b13*m.b16*m.b24 - 192*m.b13*m.b16*m.b25
- 512*m.b13*m.b16*m.b26 - 448*m.b13*m.b16*m.b27 - 384*m.b13*m.b16*m.b28 - 672*m.b13*m.b16*m.b29
- 608*m.b13*m.b16*m.b30 - 544*m.b13*m.b16*m.b31 - 480*m.b13*m.b16*m.b32 - 416*m.b13*m.b16*m.b33
- 352*m.b13*m.b16*m.b34 - 288*m.b13*m.b16*m.b35 - 224*m.b13*m.b16*m.b36 - 160*m.b13*m.b16*m.b37
- 96*m.b13*m.b16*m.b38 - 64*m.b13*m.b16*m.b39 - 32*m.b13*m.b16*m.b40 - 96*m.b13*m.b17*m.b18 - 96
*m.b13*m.b17*m.b19 - 96*m.b13*m.b17*m.b20 - 64*m.b13*m.b17*m.b21 - 96*m.b13*m.b17*m.b22 - 288*
m.b13*m.b17*m.b23 - 256*m.b13*m.b17*m.b24 - 576*m.b13*m.b17*m.b25 - 512*m.b13*m.b17*m.b26 - 448*
m.b13*m.b17*m.b27 - 384*m.b13*m.b17*m.b28 - 672*m.b13*m.b17*m.b29 - 576*m.b13*m.b17*m.b30 - 512*
m.b13*m.b17*m.b31 - 448*m.b13*m.b17*m.b32 - 384*m.b13*m.b17*m.b33 - 320*m.b13*m.b17*m.b34 - 256*
m.b13*m.b17*m.b35 - 192*m.b13*m.b17*m.b36 - 128*m.b13*m.b17*m.b37 - 96*m.b13*m.b17*m.b38 - 64*
m.b13*m.b17*m.b39 - 32*m.b13*m.b17*m.b40 - 96*m.b13*m.b18*m.b19 - 96*m.b13*m.b18*m.b20 - 96*m.b13
*m.b18*m.b21 - 96*m.b13*m.b18*m.b22 - 64*m.b13*m.b18*m.b23 - 640*m.b13*m.b18*m.b24 - 576*m.b13*
m.b18*m.b25 - 512*m.b13*m.b18*m.b26 - 448*m.b13*m.b18*m.b27 - 384*m.b13*m.b18*m.b28 - 672*m.b13*
m.b18*m.b29 - 576*m.b13*m.b18*m.b30 - 480*m.b13*m.b18*m.b31 - 416*m.b13*m.b18*m.b32 - 352*m.b13*
m.b18*m.b33 - 288*m.b13*m.b18*m.b34 - 224*m.b13*m.b18*m.b35 - 160*m.b13*m.b18*m.b36 - 128*m.b13*
m.b18*m.b37 - 96*m.b13*m.b18*m.b38 - 64*m.b13*m.b18*m.b39 - 32*m.b13*m.b18*m.b40 - 96*m.b13*m.b19
*m.b20 - 96*m.b13*m.b19*m.b21 - 96*m.b13*m.b19*m.b22 - 448*m.b13*m.b19*m.b23 - 640*m.b13*m.b19*
m.b24 - 544*m.b13*m.b19*m.b25 - 512*m.b13*m.b19*m.b26 - 448*m.b13*m.b19*m.b27 - 384*m.b13*m.b19*
m.b28 - 672*m.b13*m.b19*m.b29 - 576*m.b13*m.b19*m.b30 - 480*m.b13*m.b19*m.b31 - 384*m.b13*m.b19*
m.b32 - 320*m.b13*m.b19*m.b33 - 256*m.b13*m.b19*m.b34 - 192*m.b13*m.b19*m.b35 - 160*m.b13*m.b19*
m.b36 - 128*m.b13*m.b19*m.b37 - 96*m.b13*m.b19*m.b38 - 64*m.b13*m.b19*m.b39 - 32*m.b13*m.b19*
m.b40 - 96*m.b13*m.b20*m.b21 - 448*m.b13*m.b20*m.b22 - 416*m.b13*m.b20*m.b23 - 384*m.b13*m.b20*
m.b24 - 576*m.b13*m.b20*m.b25 - 512*m.b13*m.b20*m.b26 - 416*m.b13*m.b20*m.b27 - 384*m.b13*m.b20*
m.b28 - 672*m.b13*m.b20*m.b29 - 576*m.b13*m.b20*m.b30 - 480*m.b13*m.b20*m.b31 - 384*m.b13*m.b20*
m.b32 - 288*m.b13*m.b20*m.b33 - 224*m.b13*m.b20*m.b34 - 192*m.b13*m.b20*m.b35 - 160*m.b13*m.b20*
m.b36 - 128*m.b13*m.b20*m.b37 - 96*m.b13*m.b20*m.b38 - 64*m.b13*m.b20*m.b39 - 32*m.b13*m.b20*
m.b40 - 416*m.b13*m.b21*m.b22 - 384*m.b13*m.b21*m.b23 - 352*m.b13*m.b21*m.b24 - 576*m.b13*m.b21*
m.b25 - 512*m.b13*m.b21*m.b26 - 448*m.b13*m.b21*m.b27 - 384*m.b13*m.b21*m.b28 - 288*m.b13*m.b21*
m.b29 - 576*m.b13*m.b21*m.b30 - 480*m.b13*m.b21*m.b31 - 384*m.b13*m.b21*m.b32 - 288*m.b13*m.b21*
m.b33 - 224*m.b13*m.b21*m.b34 - 192*m.b13*m.b21*m.b35 - 160*m.b13*m.b21*m.b36 - 128*m.b13*m.b21*
m.b37 - 96*m.b13*m.b21*m.b38 - 64*m.b13*m.b21*m.b39 - 32*m.b13*m.b21*m.b40 - 352*m.b13*m.b22*
m.b23 - 320*m.b13*m.b22*m.b24 - 288*m.b13*m.b22*m.b25 - 512*m.b13*m.b22*m.b26 - 448*m.b13*m.b22*
m.b27 - 384*m.b13*m.b22*m.b28 - 672*m.b13*m.b22*m.b29 - 576*m.b13*m.b22*m.b30 - 160*m.b13*m.b22*
m.b31 - 384*m.b13*m.b22*m.b32 - 320*m.b13*m.b22*m.b33 - 256*m.b13*m.b22*m.b34 - 192*m.b13*m.b22*
m.b35 - 160*m.b13*m.b22*m.b36 - 128*m.b13*m.b22*m.b37 - 96*m.b13*m.b22*m.b38 - 64*m.b13*m.b22*
m.b39 - 32*m.b13*m.b22*m.b40 - 288*m.b13*m.b23*m.b24 - 256*m.b13*m.b23*m.b25 - 512*m.b13*m.b23*
m.b26 - 448*m.b13*m.b23*m.b27 - 384*m.b13*m.b23*m.b28 - 672*m.b13*m.b23*m.b29 - 576*m.b13*m.b23*
m.b30 - 480*m.b13*m.b23*m.b31 - 416*m.b13*m.b23*m.b32 - 96*m.b13*m.b23*m.b33 - 288*m.b13*m.b23*
m.b34 - 224*m.b13*m.b23*m.b35 - 160*m.b13*m.b23*m.b36 - 128*m.b13*m.b23*m.b37 - 96*m.b13*m.b23*
m.b38 - 64*m.b13*m.b23*m.b39 - 32*m.b13*m.b23*m.b40 - 224*m.b13*m.b24*m.b25 - 192*m.b13*m.b24*
m.b26 - 448*m.b13*m.b24*m.b27 - 384*m.b13*m.b24*m.b28 - 672*m.b13*m.b24*m.b29 - 576*m.b13*m.b24*
m.b30 - 512*m.b13*m.b24*m.b31 - 448*m.b13*m.b24*m.b32 - 384*m.b13*m.b24*m.b33 - 320*m.b13*m.b24*
m.b34 - 64*m.b13*m.b24*m.b35 - 192*m.b13*m.b24*m.b36 - 128*m.b13*m.b24*m.b37 - 96*m.b13*m.b24*
m.b38 - 64*m.b13*m.b24*m.b39 - 32*m.b13*m.b24*m.b40 - 160*m.b13*m.b25*m.b26 - 448*m.b13*m.b25*
m.b27 - 384*m.b13*m.b25*m.b28 - 672*m.b13*m.b25*m.b29 - 608*m.b13*m.b25*m.b30 - 544*m.b13*m.b25*
m.b31 - 480*m.b13*m.b25*m.b32 - 416*m.b13*m.b25*m.b33 - 352*m.b13*m.b25*m.b34 - 288*m.b13*m.b25*
m.b35 - 224*m.b13*m.b25*m.b36 - 32*m.b13*m.b25*m.b37 - 96*m.b13*m.b25*m.b38 - 64*m.b13*m.b25*
m.b39 - 32*m.b13*m.b25*m.b40 - 96*m.b13*m.b26*m.b27 - 384*m.b13*m.b26*m.b28 - 704*m.b13*m.b26*
m.b29 - 640*m.b13*m.b26*m.b30 - 576*m.b13*m.b26*m.b31 - 512*m.b13*m.b26*m.b32 - 448*m.b13*m.b26*
m.b33 - 384*m.b13*m.b26*m.b34 - 320*m.b13*m.b26*m.b35 - 256*m.b13*m.b26*m.b36 - 192*m.b13*m.b26*
m.b37 - 128*m.b13*m.b26*m.b38 - 32*m.b13*m.b26*m.b40 - 416*m.b13*m.b27*m.b28 - 736*m.b13*m.b27*
m.b29 - 672*m.b13*m.b27*m.b30 - 608*m.b13*m.b27*m.b31 - 544*m.b13*m.b27*m.b32 - 480*m.b13*m.b27*
m.b33 - 416*m.b13*m.b27*m.b34 - 352*m.b13*m.b27*m.b35 - 288*m.b13*m.b27*m.b36 - 224*m.b13*m.b27*
m.b37 - 160*m.b13*m.b27*m.b38 - 96*m.b13*m.b27*m.b39 - 32*m.b13*m.b27*m.b40 - 768*m.b13*m.b28*
m.b29 - 704*m.b13*m.b28*m.b30 - 640*m.b13*m.b28*m.b31 - 576*m.b13*m.b28*m.b32 - 512*m.b13*m.b28*
m.b33 - 448*m.b13*m.b28*m.b34 - 384*m.b13*m.b28*m.b35 - 320*m.b13*m.b28*m.b36 - 256*m.b13*m.b28*
m.b37 - 192*m.b13*m.b28*m.b38 - 128*m.b13*m.b28*m.b39 - 64*m.b13*m.b28*m.b40 - 704*m.b13*m.b29*
m.b30 - 640*m.b13*m.b29*m.b31 - 576*m.b13*m.b29*m.b32 - 512*m.b13*m.b29*m.b33 - 448*m.b13*m.b29*
m.b34 - 384*m.b13*m.b29*m.b35 - 320*m.b13*m.b29*m.b36 - 256*m.b13*m.b29*m.b37 - 192*m.b13*m.b29*
m.b38 - 128*m.b13*m.b29*m.b39 - 64*m.b13*m.b29*m.b40 - 640*m.b13*m.b30*m.b31 - 576*m.b13*m.b30*
m.b32 - 512*m.b13*m.b30*m.b33 - 448*m.b13*m.b30*m.b34 - 384*m.b13*m.b30*m.b35 - 320*m.b13*m.b30*
m.b36 - 256*m.b13*m.b30*m.b37 - 192*m.b13*m.b30*m.b38 - 128*m.b13*m.b30*m.b39 - 64*m.b13*m.b30*
m.b40 - 576*m.b13*m.b31*m.b32 - 512*m.b13*m.b31*m.b33 - 448*m.b13*m.b31*m.b34 - 384*m.b13*m.b31*
m.b35 - 320*m.b13*m.b31*m.b36 - 256*m.b13*m.b31*m.b37 - 192*m.b13*m.b31*m.b38 - 128*m.b13*m.b31*
m.b39 - 64*m.b13*m.b31*m.b40 - 512*m.b13*m.b32*m.b33 - 448*m.b13*m.b32*m.b34 - 384*m.b13*m.b32*
m.b35 - 320*m.b13*m.b32*m.b36 - 256*m.b13*m.b32*m.b37 - 192*m.b13*m.b32*m.b38 - 128*m.b13*m.b32*
m.b39 - 64*m.b13*m.b32*m.b40 - 448*m.b13*m.b33*m.b34 - 384*m.b13*m.b33*m.b35 - 320*m.b13*m.b33*
m.b36 - 256*m.b13*m.b33*m.b37 - 192*m.b13*m.b33*m.b38 - 128*m.b13*m.b33*m.b39 - 64*m.b13*m.b33*
m.b40 - 384*m.b13*m.b34*m.b35 - 320*m.b13*m.b34*m.b36 - 256*m.b13*m.b34*m.b37 - 192*m.b13*m.b34*
m.b38 - 128*m.b13*m.b34*m.b39 - 64*m.b13*m.b34*m.b40 - 320*m.b13*m.b35*m.b36 - 256*m.b13*m.b35*
m.b37 - 192*m.b13*m.b35*m.b38 - 128*m.b13*m.b35*m.b39 - 64*m.b13*m.b35*m.b40 - 256*m.b13*m.b36*
m.b37 - 192*m.b13*m.b36*m.b38 - 128*m.b13*m.b36*m.b39 - 64*m.b13*m.b36*m.b40 - 192*m.b13*m.b37*
m.b38 - 128*m.b13*m.b37*m.b39 - 64*m.b13*m.b37*m.b40 - 128*m.b13*m.b38*m.b39 - 64*m.b13*m.b38*
m.b40 - 64*m.b13*m.b39*m.b40 - 64*m.b14*m.b15*m.b16 - 96*m.b14*m.b15*m.b17 - 96*m.b14*m.b15*m.b18
- 96*m.b14*m.b15*m.b19 - 96*m.b14*m.b15*m.b20 - 96*m.b14*m.b15*m.b21 - 96*m.b14*m.b15*m.b22 -
256*m.b14*m.b15*m.b23 - 224*m.b14*m.b15*m.b24 - 192*m.b14*m.b15*m.b25 - 160*m.b14*m.b15*m.b26 -
128*m.b14*m.b15*m.b27 - 96*m.b14*m.b15*m.b28 - 384*m.b14*m.b15*m.b29 - 672*m.b14*m.b15*m.b30 -
608*m.b14*m.b15*m.b31 - 544*m.b14*m.b15*m.b32 - 480*m.b14*m.b15*m.b33 - 416*m.b14*m.b15*m.b34 -
352*m.b14*m.b15*m.b35 - 288*m.b14*m.b15*m.b36 - 224*m.b14*m.b15*m.b37 - 160*m.b14*m.b15*m.b38 -
96*m.b14*m.b15*m.b39 - 32*m.b14*m.b15*m.b40 - 96*m.b14*m.b16*m.b17 - 64*m.b14*m.b16*m.b18 - 96*
m.b14*m.b16*m.b19 - 96*m.b14*m.b16*m.b20 - 96*m.b14*m.b16*m.b21 - 96*m.b14*m.b16*m.b22 - 288*
m.b14*m.b16*m.b23 - 256*m.b14*m.b16*m.b24 - 224*m.b14*m.b16*m.b25 - 192*m.b14*m.b16*m.b26 - 160*
m.b14*m.b16*m.b27 - 448*m.b14*m.b16*m.b28 - 384*m.b14*m.b16*m.b29 - 640*m.b14*m.b16*m.b30 - 576*
m.b14*m.b16*m.b31 - 512*m.b14*m.b16*m.b32 - 448*m.b14*m.b16*m.b33 - 384*m.b14*m.b16*m.b34 - 320*
m.b14*m.b16*m.b35 - 256*m.b14*m.b16*m.b36 - 192*m.b14*m.b16*m.b37 - 128*m.b14*m.b16*m.b38 - 64*
m.b14*m.b16*m.b39 - 32*m.b14*m.b16*m.b40 - 96*m.b14*m.b17*m.b18 - 96*m.b14*m.b17*m.b19 - 64*m.b14
*m.b17*m.b20 - 96*m.b14*m.b17*m.b21 - 96*m.b14*m.b17*m.b22 - 96*m.b14*m.b17*m.b23 - 288*m.b14*
m.b17*m.b24 - 256*m.b14*m.b17*m.b25 - 224*m.b14*m.b17*m.b26 - 512*m.b14*m.b17*m.b27 - 448*m.b14*
m.b17*m.b28 - 384*m.b14*m.b17*m.b29 - 640*m.b14*m.b17*m.b30 - 544*m.b14*m.b17*m.b31 - 480*m.b14*
m.b17*m.b32 - 416*m.b14*m.b17*m.b33 - 352*m.b14*m.b17*m.b34 - 288*m.b14*m.b17*m.b35 - 224*m.b14*
m.b17*m.b36 - 160*m.b14*m.b17*m.b37 - 96*m.b14*m.b17*m.b38 - 64*m.b14*m.b17*m.b39 - 32*m.b14*
m.b17*m.b40 - 96*m.b14*m.b18*m.b19 - 96*m.b14*m.b18*m.b20 - 96*m.b14*m.b18*m.b21 - 64*m.b14*m.b18
*m.b22 - 96*m.b14*m.b18*m.b23 - 320*m.b14*m.b18*m.b24 - 288*m.b14*m.b18*m.b25 - 576*m.b14*m.b18*
m.b26 - 512*m.b14*m.b18*m.b27 - 448*m.b14*m.b18*m.b28 - 384*m.b14*m.b18*m.b29 - 640*m.b14*m.b18*
m.b30 - 544*m.b14*m.b18*m.b31 - 448*m.b14*m.b18*m.b32 - 384*m.b14*m.b18*m.b33 - 320*m.b14*m.b18*
m.b34 - 256*m.b14*m.b18*m.b35 - 192*m.b14*m.b18*m.b36 - 128*m.b14*m.b18*m.b37 - 96*m.b14*m.b18*
m.b38 - 64*m.b14*m.b18*m.b39 - 32*m.b14*m.b18*m.b40 - 96*m.b14*m.b19*m.b20 - 96*m.b14*m.b19*m.b21
- 96*m.b14*m.b19*m.b22 - 96*m.b14*m.b19*m.b23 - 64*m.b14*m.b19*m.b24 - 640*m.b14*m.b19*m.b25 -
576*m.b14*m.b19*m.b26 - 512*m.b14*m.b19*m.b27 - 448*m.b14*m.b19*m.b28 - 384*m.b14*m.b19*m.b29 -
640*m.b14*m.b19*m.b30 - 544*m.b14*m.b19*m.b31 - 448*m.b14*m.b19*m.b32 - 352*m.b14*m.b19*m.b33 -
288*m.b14*m.b19*m.b34 - 224*m.b14*m.b19*m.b35 - 160*m.b14*m.b19*m.b36 - 128*m.b14*m.b19*m.b37 -
96*m.b14*m.b19*m.b38 - 64*m.b14*m.b19*m.b39 - 32*m.b14*m.b19*m.b40 - 96*m.b14*m.b20*m.b21 - 96*
m.b14*m.b20*m.b22 - 96*m.b14*m.b20*m.b23 - 416*m.b14*m.b20*m.b24 - 640*m.b14*m.b20*m.b25 - 544*
m.b14*m.b20*m.b26 - 512*m.b14*m.b20*m.b27 - 448*m.b14*m.b20*m.b28 - 384*m.b14*m.b20*m.b29 - 640*
m.b14*m.b20*m.b30 - 544*m.b14*m.b20*m.b31 - 448*m.b14*m.b20*m.b32 - 352*m.b14*m.b20*m.b33 - 256*
m.b14*m.b20*m.b34 - 192*m.b14*m.b20*m.b35 - 160*m.b14*m.b20*m.b36 - 128*m.b14*m.b20*m.b37 - 96*
m.b14*m.b20*m.b38 - 64*m.b14*m.b20*m.b39 - 32*m.b14*m.b20*m.b40 - 96*m.b14*m.b21*m.b22 - 416*
m.b14*m.b21*m.b23 - 384*m.b14*m.b21*m.b24 - 352*m.b14*m.b21*m.b25 - 576*m.b14*m.b21*m.b26 - 512*
m.b14*m.b21*m.b27 - 416*m.b14*m.b21*m.b28 - 384*m.b14*m.b21*m.b29 - 640*m.b14*m.b21*m.b30 - 544*
m.b14*m.b21*m.b31 - 448*m.b14*m.b21*m.b32 - 352*m.b14*m.b21*m.b33 - 256*m.b14*m.b21*m.b34 - 192*
m.b14*m.b21*m.b35 - 160*m.b14*m.b21*m.b36 - 128*m.b14*m.b21*m.b37 - 96*m.b14*m.b21*m.b38 - 64*
m.b14*m.b21*m.b39 - 32*m.b14*m.b21*m.b40 - 384*m.b14*m.b22*m.b23 - 352*m.b14*m.b22*m.b24 - 320*
m.b14*m.b22*m.b25 - 576*m.b14*m.b22*m.b26 - 512*m.b14*m.b22*m.b27 - 448*m.b14*m.b22*m.b28 - 384*
m.b14*m.b22*m.b29 - 288*m.b14*m.b22*m.b30 - 544*m.b14*m.b22*m.b31 - 448*m.b14*m.b22*m.b32 - 352*
m.b14*m.b22*m.b33 - 288*m.b14*m.b22*m.b34 - 224*m.b14*m.b22*m.b35 - 160*m.b14*m.b22*m.b36 - 128*
m.b14*m.b22*m.b37 - 96*m.b14*m.b22*m.b38 - 64*m.b14*m.b22*m.b39 - 32*m.b14*m.b22*m.b40 - 320*
m.b14*m.b23*m.b24 - 288*m.b14*m.b23*m.b25 - 256*m.b14*m.b23*m.b26 - 512*m.b14*m.b23*m.b27 - 448*
m.b14*m.b23*m.b28 - 384*m.b14*m.b23*m.b29 - 640*m.b14*m.b23*m.b30 - 544*m.b14*m.b23*m.b31 - 160*
m.b14*m.b23*m.b32 - 384*m.b14*m.b23*m.b33 - 320*m.b14*m.b23*m.b34 - 256*m.b14*m.b23*m.b35 - 192*
m.b14*m.b23*m.b36 - 128*m.b14*m.b23*m.b37 - 96*m.b14*m.b23*m.b38 - 64*m.b14*m.b23*m.b39 - 32*
m.b14*m.b23*m.b40 - 256*m.b14*m.b24*m.b25 - 224*m.b14*m.b24*m.b26 - 512*m.b14*m.b24*m.b27 - 448*
m.b14*m.b24*m.b28 - 384*m.b14*m.b24*m.b29 - 640*m.b14*m.b24*m.b30 - 544*m.b14*m.b24*m.b31 - 480*
m.b14*m.b24*m.b32 - 416*m.b14*m.b24*m.b33 - 128*m.b14*m.b24*m.b34 - 288*m.b14*m.b24*m.b35 - 224*
m.b14*m.b24*m.b36 - 160*m.b14*m.b24*m.b37 - 96*m.b14*m.b24*m.b38 - 64*m.b14*m.b24*m.b39 - 32*
m.b14*m.b24*m.b40 - 192*m.b14*m.b25*m.b26 - 160*m.b14*m.b25*m.b27 - 448*m.b14*m.b25*m.b28 - 384*
m.b14*m.b25*m.b29 - 640*m.b14*m.b25*m.b30 - 576*m.b14*m.b25*m.b31 - 512*m.b14*m.b25*m.b32 - 448*
m.b14*m.b25*m.b33 - 384*m.b14*m.b25*m.b34 - 320*m.b14*m.b25*m.b35 - 96*m.b14*m.b25*m.b36 - 192*
m.b14*m.b25*m.b37 - 128*m.b14*m.b25*m.b38 - 64*m.b14*m.b25*m.b39 - 32*m.b14*m.b25*m.b40 - 128*
m.b14*m.b26*m.b27 - 448*m.b14*m.b26*m.b28 - 384*m.b14*m.b26*m.b29 - 672*m.b14*m.b26*m.b30 - 608*
m.b14*m.b26*m.b31 - 544*m.b14*m.b26*m.b32 - 480*m.b14*m.b26*m.b33 - 416*m.b14*m.b26*m.b34 - 352*
m.b14*m.b26*m.b35 - 288*m.b14*m.b26*m.b36 - 224*m.b14*m.b26*m.b37 - 64*m.b14*m.b26*m.b38 - 96*
m.b14*m.b26*m.b39 - 32*m.b14*m.b26*m.b40 - 64*m.b14*m.b27*m.b28 - 416*m.b14*m.b27*m.b29 - 704*
m.b14*m.b27*m.b30 - 640*m.b14*m.b27*m.b31 - 576*m.b14*m.b27*m.b32 - 512*m.b14*m.b27*m.b33 - 448*
m.b14*m.b27*m.b34 - 384*m.b14*m.b27*m.b35 - 320*m.b14*m.b27*m.b36 - 256*m.b14*m.b27*m.b37 - 192*
m.b14*m.b27*m.b38 - 128*m.b14*m.b27*m.b39 - 32*m.b14*m.b27*m.b40 - 416*m.b14*m.b28*m.b29 - 704*
m.b14*m.b28*m.b30 - 640*m.b14*m.b28*m.b31 - 576*m.b14*m.b28*m.b32 - 512*m.b14*m.b28*m.b33 - 448*
m.b14*m.b28*m.b34 - 384*m.b14*m.b28*m.b35 - 320*m.b14*m.b28*m.b36 - 256*m.b14*m.b28*m.b37 - 192*
m.b14*m.b28*m.b38 - 128*m.b14*m.b28*m.b39 - 64*m.b14*m.b28*m.b40 - 704*m.b14*m.b29*m.b30 - 640*
m.b14*m.b29*m.b31 - 576*m.b14*m.b29*m.b32 - 512*m.b14*m.b29*m.b33 - 448*m.b14*m.b29*m.b34 - 384*
m.b14*m.b29*m.b35 - 320*m.b14*m.b29*m.b36 - 256*m.b14*m.b29*m.b37 - 192*m.b14*m.b29*m.b38 - 128*
m.b14*m.b29*m.b39 - 64*m.b14*m.b29*m.b40 - 640*m.b14*m.b30*m.b31 - 576*m.b14*m.b30*m.b32 - 512*
m.b14*m.b30*m.b33 - 448*m.b14*m.b30*m.b34 - 384*m.b14*m.b30*m.b35 - 320*m.b14*m.b30*m.b36 - 256*
m.b14*m.b30*m.b37 - 192*m.b14*m.b30*m.b38 - 128*m.b14*m.b30*m.b39 - 64*m.b14*m.b30*m.b40 - 576*
m.b14*m.b31*m.b32 - 512*m.b14*m.b31*m.b33 - 448*m.b14*m.b31*m.b34 - 384*m.b14*m.b31*m.b35 - 320*
m.b14*m.b31*m.b36 - 256*m.b14*m.b31*m.b37 - 192*m.b14*m.b31*m.b38 - 128*m.b14*m.b31*m.b39 - 64*
m.b14*m.b31*m.b40 - 512*m.b14*m.b32*m.b33 - 448*m.b14*m.b32*m.b34 - 384*m.b14*m.b32*m.b35 - 320*
m.b14*m.b32*m.b36 - 256*m.b14*m.b32*m.b37 - 192*m.b14*m.b32*m.b38 - 128*m.b14*m.b32*m.b39 - 64*
m.b14*m.b32*m.b40 - 448*m.b14*m.b33*m.b34 - 384*m.b14*m.b33*m.b35 - 320*m.b14*m.b33*m.b36 - 256*
m.b14*m.b33*m.b37 - 192*m.b14*m.b33*m.b38 - 128*m.b14*m.b33*m.b39 - 64*m.b14*m.b33*m.b40 - 384*
m.b14*m.b34*m.b35 - 320*m.b14*m.b34*m.b36 - 256*m.b14*m.b34*m.b37 - 192*m.b14*m.b34*m.b38 - 128*
m.b14*m.b34*m.b39 - 64*m.b14*m.b34*m.b40 - 320*m.b14*m.b35*m.b36 - 256*m.b14*m.b35*m.b37 - 192*
m.b14*m.b35*m.b38 - 128*m.b14*m.b35*m.b39 - 64*m.b14*m.b35*m.b40 - 256*m.b14*m.b36*m.b37 - 192*
m.b14*m.b36*m.b38 - 128*m.b14*m.b36*m.b39 - 64*m.b14*m.b36*m.b40 - 192*m.b14*m.b37*m.b38 - 128*
m.b14*m.b37*m.b39 - 64*m.b14*m.b37*m.b40 - 128*m.b14*m.b38*m.b39 - 64*m.b14*m.b38*m.b40 - 64*
m.b14*m.b39*m.b40 - 64*m.b15*m.b16*m.b17 - 96*m.b15*m.b16*m.b18 - 96*m.b15*m.b16*m.b19 - 96*m.b15
*m.b16*m.b20 - 96*m.b15*m.b16*m.b21 - 96*m.b15*m.b16*m.b22 - 96*m.b15*m.b16*m.b23 - 288*m.b15*
m.b16*m.b24 - 256*m.b15*m.b16*m.b25 - 224*m.b15*m.b16*m.b26 - 192*m.b15*m.b16*m.b27 - 160*m.b15*
m.b16*m.b28 - 128*m.b15*m.b16*m.b29 - 384*m.b15*m.b16*m.b30 - 608*m.b15*m.b16*m.b31 - 544*m.b15*
m.b16*m.b32 - 480*m.b15*m.b16*m.b33 - 416*m.b15*m.b16*m.b34 - 352*m.b15*m.b16*m.b35 - 288*m.b15*
m.b16*m.b36 - 224*m.b15*m.b16*m.b37 - 160*m.b15*m.b16*m.b38 - 96*m.b15*m.b16*m.b39 - 32*m.b15*
m.b16*m.b40 - 96*m.b15*m.b17*m.b18 - 64*m.b15*m.b17*m.b19 - 96*m.b15*m.b17*m.b20 - 96*m.b15*m.b17
*m.b21 - 96*m.b15*m.b17*m.b22 - 96*m.b15*m.b17*m.b23 - 320*m.b15*m.b17*m.b24 - 288*m.b15*m.b17*
m.b25 - 256*m.b15*m.b17*m.b26 - 224*m.b15*m.b17*m.b27 - 192*m.b15*m.b17*m.b28 - 448*m.b15*m.b17*
m.b29 - 384*m.b15*m.b17*m.b30 - 608*m.b15*m.b17*m.b31 - 512*m.b15*m.b17*m.b32 - 448*m.b15*m.b17*
m.b33 - 384*m.b15*m.b17*m.b34 - 320*m.b15*m.b17*m.b35 - 256*m.b15*m.b17*m.b36 - 192*m.b15*m.b17*
m.b37 - 128*m.b15*m.b17*m.b38 - 64*m.b15*m.b17*m.b39 - 32*m.b15*m.b17*m.b40 - 96*m.b15*m.b18*
m.b19 - 96*m.b15*m.b18*m.b20 - 64*m.b15*m.b18*m.b21 - 96*m.b15*m.b18*m.b22 - 96*m.b15*m.b18*m.b23
- 96*m.b15*m.b18*m.b24 - 320*m.b15*m.b18*m.b25 - 288*m.b15*m.b18*m.b26 - 256*m.b15*m.b18*m.b27
- 512*m.b15*m.b18*m.b28 - 448*m.b15*m.b18*m.b29 - 384*m.b15*m.b18*m.b30 - 608*m.b15*m.b18*m.b31
- 512*m.b15*m.b18*m.b32 - 416*m.b15*m.b18*m.b33 - 352*m.b15*m.b18*m.b34 - 288*m.b15*m.b18*m.b35
- 224*m.b15*m.b18*m.b36 - 160*m.b15*m.b18*m.b37 - 96*m.b15*m.b18*m.b38 - 64*m.b15*m.b18*m.b39 -
32*m.b15*m.b18*m.b40 - 96*m.b15*m.b19*m.b20 - 96*m.b15*m.b19*m.b21 - 96*m.b15*m.b19*m.b22 - 64*
m.b15*m.b19*m.b23 - 96*m.b15*m.b19*m.b24 - 352*m.b15*m.b19*m.b25 - 320*m.b15*m.b19*m.b26 - 576*
m.b15*m.b19*m.b27 - 512*m.b15*m.b19*m.b28 - 448*m.b15*m.b19*m.b29 - 384*m.b15*m.b19*m.b30 - 608*
m.b15*m.b19*m.b31 - 512*m.b15*m.b19*m.b32 - 416*m.b15*m.b19*m.b33 - 320*m.b15*m.b19*m.b34 - 256*
m.b15*m.b19*m.b35 - 192*m.b15*m.b19*m.b36 - 128*m.b15*m.b19*m.b37 - 96*m.b15*m.b19*m.b38 - 64*
m.b15*m.b19*m.b39 - 32*m.b15*m.b19*m.b40 - 96*m.b15*m.b20*m.b21 - 96*m.b15*m.b20*m.b22 - 96*m.b15
*m.b20*m.b23 - 96*m.b15*m.b20*m.b24 - 64*m.b15*m.b20*m.b25 - 640*m.b15*m.b20*m.b26 - 576*m.b15*
m.b20*m.b27 - 512*m.b15*m.b20*m.b28 - 448*m.b15*m.b20*m.b29 - 384*m.b15*m.b20*m.b30 - 608*m.b15*
m.b20*m.b31 - 512*m.b15*m.b20*m.b32 - 416*m.b15*m.b20*m.b33 - 320*m.b15*m.b20*m.b34 - 224*m.b15*
m.b20*m.b35 - 160*m.b15*m.b20*m.b36 - 128*m.b15*m.b20*m.b37 - 96*m.b15*m.b20*m.b38 - 64*m.b15*
m.b20*m.b39 - 32*m.b15*m.b20*m.b40 - 96*m.b15*m.b21*m.b22 - 96*m.b15*m.b21*m.b23 - 96*m.b15*m.b21
*m.b24 - 384*m.b15*m.b21*m.b25 - 640*m.b15*m.b21*m.b26 - 544*m.b15*m.b21*m.b27 - 512*m.b15*m.b21*
m.b28 - 448*m.b15*m.b21*m.b29 - 384*m.b15*m.b21*m.b30 - 608*m.b15*m.b21*m.b31 - 512*m.b15*m.b21*
m.b32 - 416*m.b15*m.b21*m.b33 - 320*m.b15*m.b21*m.b34 - 224*m.b15*m.b21*m.b35 - 160*m.b15*m.b21*
m.b36 - 128*m.b15*m.b21*m.b37 - 96*m.b15*m.b21*m.b38 - 64*m.b15*m.b21*m.b39 - 32*m.b15*m.b21*
m.b40 - 96*m.b15*m.b22*m.b23 - 384*m.b15*m.b22*m.b24 - 352*m.b15*m.b22*m.b25 - 320*m.b15*m.b22*
m.b26 - 576*m.b15*m.b22*m.b27 - 512*m.b15*m.b22*m.b28 - 416*m.b15*m.b22*m.b29 - 384*m.b15*m.b22*
m.b30 - 608*m.b15*m.b22*m.b31 - 512*m.b15*m.b22*m.b32 - 416*m.b15*m.b22*m.b33 - 320*m.b15*m.b22*
m.b34 - 256*m.b15*m.b22*m.b35 - 192*m.b15*m.b22*m.b36 - 128*m.b15*m.b22*m.b37 - 96*m.b15*m.b22*
m.b38 - 64*m.b15*m.b22*m.b39 - 32*m.b15*m.b22*m.b40 - 352*m.b15*m.b23*m.b24 - 320*m.b15*m.b23*
m.b25 - 288*m.b15*m.b23*m.b26 - 576*m.b15*m.b23*m.b27 - 512*m.b15*m.b23*m.b28 - 448*m.b15*m.b23*
m.b29 - 384*m.b15*m.b23*m.b30 - 288*m.b15*m.b23*m.b31 - 512*m.b15*m.b23*m.b32 - 416*m.b15*m.b23*
m.b33 - 352*m.b15*m.b23*m.b34 - 288*m.b15*m.b23*m.b35 - 224*m.b15*m.b23*m.b36 - 160*m.b15*m.b23*
m.b37 - 96*m.b15*m.b23*m.b38 - 64*m.b15*m.b23*m.b39 - 32*m.b15*m.b23*m.b40 - 288*m.b15*m.b24*
m.b25 - 256*m.b15*m.b24*m.b26 - 224*m.b15*m.b24*m.b27 - 512*m.b15*m.b24*m.b28 - 448*m.b15*m.b24*
m.b29 - 384*m.b15*m.b24*m.b30 - 608*m.b15*m.b24*m.b31 - 512*m.b15*m.b24*m.b32 - 192*m.b15*m.b24*
m.b33 - 384*m.b15*m.b24*m.b34 - 320*m.b15*m.b24*m.b35 - 256*m.b15*m.b24*m.b36 - 192*m.b15*m.b24*
m.b37 - 128*m.b15*m.b24*m.b38 - 64*m.b15*m.b24*m.b39 - 32*m.b15*m.b24*m.b40 - 224*m.b15*m.b25*
m.b26 - 192*m.b15*m.b25*m.b27 - 512*m.b15*m.b25*m.b28 - 448*m.b15*m.b25*m.b29 - 384*m.b15*m.b25*
m.b30 - 608*m.b15*m.b25*m.b31 - 544*m.b15*m.b25*m.b32 - 480*m.b15*m.b25*m.b33 - 416*m.b15*m.b25*
m.b34 - 160*m.b15*m.b25*m.b35 - 288*m.b15*m.b25*m.b36 - 224*m.b15*m.b25*m.b37 - 160*m.b15*m.b25*
m.b38 - 96*m.b15*m.b25*m.b39 - 32*m.b15*m.b25*m.b40 - 160*m.b15*m.b26*m.b27 - 128*m.b15*m.b26*
m.b28 - 448*m.b15*m.b26*m.b29 - 384*m.b15*m.b26*m.b30 - 640*m.b15*m.b26*m.b31 - 576*m.b15*m.b26*
m.b32 - 512*m.b15*m.b26*m.b33 - 448*m.b15*m.b26*m.b34 - 384*m.b15*m.b26*m.b35 - 320*m.b15*m.b26*
m.b36 - 128*m.b15*m.b26*m.b37 - 192*m.b15*m.b26*m.b38 - 128*m.b15*m.b26*m.b39 - 64*m.b15*m.b26*
m.b40 - 96*m.b15*m.b27*m.b28 - 416*m.b15*m.b27*m.b29 - 384*m.b15*m.b27*m.b30 - 640*m.b15*m.b27*
m.b31 - 576*m.b15*m.b27*m.b32 - 512*m.b15*m.b27*m.b33 - 448*m.b15*m.b27*m.b34 - 384*m.b15*m.b27*
m.b35 - 320*m.b15*m.b27*m.b36 - 256*m.b15*m.b27*m.b37 - 192*m.b15*m.b27*m.b38 - 64*m.b15*m.b27*
m.b39 - 64*m.b15*m.b27*m.b40 - 64*m.b15*m.b28*m.b29 - 384*m.b15*m.b28*m.b30 - 640*m.b15*m.b28*
m.b31 - 576*m.b15*m.b28*m.b32 - 512*m.b15*m.b28*m.b33 - 448*m.b15*m.b28*m.b34 - 384*m.b15*m.b28*
m.b35 - 320*m.b15*m.b28*m.b36 - 256*m.b15*m.b28*m.b37 - 192*m.b15*m.b28*m.b38 - 128*m.b15*m.b28*
m.b39 - 64*m.b15*m.b28*m.b40 - 384*m.b15*m.b29*m.b30 - 640*m.b15*m.b29*m.b31 - 576*m.b15*m.b29*
m.b32 - 512*m.b15*m.b29*m.b33 - 448*m.b15*m.b29*m.b34 - 384*m.b15*m.b29*m.b35 - 320*m.b15*m.b29*
m.b36 - 256*m.b15*m.b29*m.b37 - 192*m.b15*m.b29*m.b38 - 128*m.b15*m.b29*m.b39 - 64*m.b15*m.b29*
m.b40 - 640*m.b15*m.b30*m.b31 - 576*m.b15*m.b30*m.b32 - 512*m.b15*m.b30*m.b33 - 448*m.b15*m.b30*
m.b34 - 384*m.b15*m.b30*m.b35 - 320*m.b15*m.b30*m.b36 - 256*m.b15*m.b30*m.b37 - 192*m.b15*m.b30*
m.b38 - 128*m.b15*m.b30*m.b39 - 64*m.b15*m.b30*m.b40 - 576*m.b15*m.b31*m.b32 - 512*m.b15*m.b31*
m.b33 - 448*m.b15*m.b31*m.b34 - 384*m.b15*m.b31*m.b35 - 320*m.b15*m.b31*m.b36 - 256*m.b15*m.b31*
m.b37 - 192*m.b15*m.b31*m.b38 - 128*m.b15*m.b31*m.b39 - 64*m.b15*m.b31*m.b40 - 512*m.b15*m.b32*
m.b33 - 448*m.b15*m.b32*m.b34 - 384*m.b15*m.b32*m.b35 - 320*m.b15*m.b32*m.b36 - 256*m.b15*m.b32*
m.b37 - 192*m.b15*m.b32*m.b38 - 128*m.b15*m.b32*m.b39 - 64*m.b15*m.b32*m.b40 - 448*m.b15*m.b33*
m.b34 - 384*m.b15*m.b33*m.b35 - 320*m.b15*m.b33*m.b36 - 256*m.b15*m.b33*m.b37 - 192*m.b15*m.b33*
m.b38 - 128*m.b15*m.b33*m.b39 - 64*m.b15*m.b33*m.b40 - 384*m.b15*m.b34*m.b35 - 320*m.b15*m.b34*
m.b36 - 256*m.b15*m.b34*m.b37 - 192*m.b15*m.b34*m.b38 - 128*m.b15*m.b34*m.b39 - 64*m.b15*m.b34*
m.b40 - 320*m.b15*m.b35*m.b36 - 256*m.b15*m.b35*m.b37 - 192*m.b15*m.b35*m.b38 - 128*m.b15*m.b35*
m.b39 - 64*m.b15*m.b35*m.b40 - 256*m.b15*m.b36*m.b37 - 192*m.b15*m.b36*m.b38 - 128*m.b15*m.b36*
m.b39 - 64*m.b15*m.b36*m.b40 - 192*m.b15*m.b37*m.b38 - 128*m.b15*m.b37*m.b39 - 64*m.b15*m.b37*
m.b40 - 128*m.b15*m.b38*m.b39 - 64*m.b15*m.b38*m.b40 - 64*m.b15*m.b39*m.b40 - 64*m.b16*m.b17*
m.b18 - 96*m.b16*m.b17*m.b19 - 96*m.b16*m.b17*m.b20 - 96*m.b16*m.b17*m.b21 - 96*m.b16*m.b17*m.b22
- 96*m.b16*m.b17*m.b23 - 96*m.b16*m.b17*m.b24 - 320*m.b16*m.b17*m.b25 - 288*m.b16*m.b17*m.b26 -
256*m.b16*m.b17*m.b27 - 224*m.b16*m.b17*m.b28 - 192*m.b16*m.b17*m.b29 - 160*m.b16*m.b17*m.b30 -
384*m.b16*m.b17*m.b31 - 576*m.b16*m.b17*m.b32 - 480*m.b16*m.b17*m.b33 - 416*m.b16*m.b17*m.b34 -
352*m.b16*m.b17*m.b35 - 288*m.b16*m.b17*m.b36 - 224*m.b16*m.b17*m.b37 - 160*m.b16*m.b17*m.b38 -
96*m.b16*m.b17*m.b39 - 32*m.b16*m.b17*m.b40 - 96*m.b16*m.b18*m.b19 - 64*m.b16*m.b18*m.b20 - 96*
m.b16*m.b18*m.b21 - 96*m.b16*m.b18*m.b22 - 96*m.b16*m.b18*m.b23 - 96*m.b16*m.b18*m.b24 - 352*
m.b16*m.b18*m.b25 - 320*m.b16*m.b18*m.b26 - 288*m.b16*m.b18*m.b27 - 256*m.b16*m.b18*m.b28 - 224*
m.b16*m.b18*m.b29 - 448*m.b16*m.b18*m.b30 - 384*m.b16*m.b18*m.b31 - 576*m.b16*m.b18*m.b32 - 480*
m.b16*m.b18*m.b33 - 384*m.b16*m.b18*m.b34 - 320*m.b16*m.b18*m.b35 - 256*m.b16*m.b18*m.b36 - 192*
m.b16*m.b18*m.b37 - 128*m.b16*m.b18*m.b38 - 64*m.b16*m.b18*m.b39 - 32*m.b16*m.b18*m.b40 - 96*
m.b16*m.b19*m.b20 - 96*m.b16*m.b19*m.b21 - 64*m.b16*m.b19*m.b22 - 96*m.b16*m.b19*m.b23 - 96*m.b16
*m.b19*m.b24 - 96*m.b16*m.b19*m.b25 - 352*m.b16*m.b19*m.b26 - 320*m.b16*m.b19*m.b27 - 288*m.b16*
m.b19*m.b28 - 512*m.b16*m.b19*m.b29 - 448*m.b16*m.b19*m.b30 - 384*m.b16*m.b19*m.b31 - 576*m.b16*
m.b19*m.b32 - 480*m.b16*m.b19*m.b33 - 384*m.b16*m.b19*m.b34 - 288*m.b16*m.b19*m.b35 - 224*m.b16*
m.b19*m.b36 - 160*m.b16*m.b19*m.b37 - 96*m.b16*m.b19*m.b38 - 64*m.b16*m.b19*m.b39 - 32*m.b16*
m.b19*m.b40 - 96*m.b16*m.b20*m.b21 - 96*m.b16*m.b20*m.b22 - 96*m.b16*m.b20*m.b23 - 64*m.b16*m.b20
*m.b24 - 96*m.b16*m.b20*m.b25 - 384*m.b16*m.b20*m.b26 - 352*m.b16*m.b20*m.b27 - 576*m.b16*m.b20*
m.b28 - 512*m.b16*m.b20*m.b29 - 448*m.b16*m.b20*m.b30 - 384*m.b16*m.b20*m.b31 - 576*m.b16*m.b20*
m.b32 - 480*m.b16*m.b20*m.b33 - 384*m.b16*m.b20*m.b34 - 288*m.b16*m.b20*m.b35 - 192*m.b16*m.b20*
m.b36 - 128*m.b16*m.b20*m.b37 - 96*m.b16*m.b20*m.b38 - 64*m.b16*m.b20*m.b39 - 32*m.b16*m.b20*
m.b40 - 96*m.b16*m.b21*m.b22 - 96*m.b16*m.b21*m.b23 - 96*m.b16*m.b21*m.b24 - 96*m.b16*m.b21*m.b25
- 64*m.b16*m.b21*m.b26 - 640*m.b16*m.b21*m.b27 - 576*m.b16*m.b21*m.b28 - 512*m.b16*m.b21*m.b29
- 448*m.b16*m.b21*m.b30 - 384*m.b16*m.b21*m.b31 - 576*m.b16*m.b21*m.b32 - 480*m.b16*m.b21*m.b33
- 384*m.b16*m.b21*m.b34 - 288*m.b16*m.b21*m.b35 - 192*m.b16*m.b21*m.b36 - 128*m.b16*m.b21*m.b37
- 96*m.b16*m.b21*m.b38 - 64*m.b16*m.b21*m.b39 - 32*m.b16*m.b21*m.b40 - 96*m.b16*m.b22*m.b23 - 96
*m.b16*m.b22*m.b24 - 96*m.b16*m.b22*m.b25 - 352*m.b16*m.b22*m.b26 - 640*m.b16*m.b22*m.b27 - 544*
m.b16*m.b22*m.b28 - 512*m.b16*m.b22*m.b29 - 448*m.b16*m.b22*m.b30 - 384*m.b16*m.b22*m.b31 - 576*
m.b16*m.b22*m.b32 - 480*m.b16*m.b22*m.b33 - 384*m.b16*m.b22*m.b34 - 288*m.b16*m.b22*m.b35 - 224*
m.b16*m.b22*m.b36 - 160*m.b16*m.b22*m.b37 - 96*m.b16*m.b22*m.b38 - 64*m.b16*m.b22*m.b39 - 32*
m.b16*m.b22*m.b40 - 96*m.b16*m.b23*m.b24 - 352*m.b16*m.b23*m.b25 - 320*m.b16*m.b23*m.b26 - 288*
m.b16*m.b23*m.b27 - 576*m.b16*m.b23*m.b28 - 512*m.b16*m.b23*m.b29 - 416*m.b16*m.b23*m.b30 - 384*
m.b16*m.b23*m.b31 - 576*m.b16*m.b23*m.b32 - 480*m.b16*m.b23*m.b33 - 384*m.b16*m.b23*m.b34 - 320*
m.b16*m.b23*m.b35 - 256*m.b16*m.b23*m.b36 - 192*m.b16*m.b23*m.b37 - 128*m.b16*m.b23*m.b38 - 64*
m.b16*m.b23*m.b39 - 32*m.b16*m.b23*m.b40 - 320*m.b16*m.b24*m.b25 - 288*m.b16*m.b24*m.b26 - 256*
m.b16*m.b24*m.b27 - 576*m.b16*m.b24*m.b28 - 512*m.b16*m.b24*m.b29 - 448*m.b16*m.b24*m.b30 - 384*
m.b16*m.b24*m.b31 - 288*m.b16*m.b24*m.b32 - 480*m.b16*m.b24*m.b33 - 416*m.b16*m.b24*m.b34 - 352*
m.b16*m.b24*m.b35 - 288*m.b16*m.b24*m.b36 - 224*m.b16*m.b24*m.b37 - 160*m.b16*m.b24*m.b38 - 96*
m.b16*m.b24*m.b39 - 32*m.b16*m.b24*m.b40 - 256*m.b16*m.b25*m.b26 - 224*m.b16*m.b25*m.b27 - 192*
m.b16*m.b25*m.b28 - 512*m.b16*m.b25*m.b29 - 448*m.b16*m.b25*m.b30 - 384*m.b16*m.b25*m.b31 - 576*
m.b16*m.b25*m.b32 - 512*m.b16*m.b25*m.b33 - 224*m.b16*m.b25*m.b34 - 384*m.b16*m.b25*m.b35 - 320*
m.b16*m.b25*m.b36 - 256*m.b16*m.b25*m.b37 - 192*m.b16*m.b25*m.b38 - 128*m.b16*m.b25*m.b39 - 64*
m.b16*m.b25*m.b40 - 192*m.b16*m.b26*m.b27 - 160*m.b16*m.b26*m.b28 - 480*m.b16*m.b26*m.b29 - 416*
m.b16*m.b26*m.b30 - 352*m.b16*m.b26*m.b31 - 576*m.b16*m.b26*m.b32 - 512*m.b16*m.b26*m.b33 - 448*
m.b16*m.b26*m.b34 - 384*m.b16*m.b26*m.b35 - 160*m.b16*m.b26*m.b36 - 256*m.b16*m.b26*m.b37 - 192*
m.b16*m.b26*m.b38 - 128*m.b16*m.b26*m.b39 - 64*m.b16*m.b26*m.b40 - 128*m.b16*m.b27*m.b28 - 96*
m.b16*m.b27*m.b29 - 384*m.b16*m.b27*m.b30 - 352*m.b16*m.b27*m.b31 - 576*m.b16*m.b27*m.b32 - 512*
m.b16*m.b27*m.b33 - 448*m.b16*m.b27*m.b34 - 384*m.b16*m.b27*m.b35 - 320*m.b16*m.b27*m.b36 - 256*
m.b16*m.b27*m.b37 - 96*m.b16*m.b27*m.b38 - 128*m.b16*m.b27*m.b39 - 64*m.b16*m.b27*m.b40 - 64*
m.b16*m.b28*m.b29 - 384*m.b16*m.b28*m.b30 - 352*m.b16*m.b28*m.b31 - 576*m.b16*m.b28*m.b32 - 512*
m.b16*m.b28*m.b33 - 448*m.b16*m.b28*m.b34 - 384*m.b16*m.b28*m.b35 - 320*m.b16*m.b28*m.b36 - 256*
m.b16*m.b28*m.b37 - 192*m.b16*m.b28*m.b38 - 128*m.b16*m.b28*m.b39 - 32*m.b16*m.b28*m.b40 - 64*
m.b16*m.b29*m.b30 - 352*m.b16*m.b29*m.b31 - 576*m.b16*m.b29*m.b32 - 512*m.b16*m.b29*m.b33 - 448*
m.b16*m.b29*m.b34 - 384*m.b16*m.b29*m.b35 - 320*m.b16*m.b29*m.b36 - 256*m.b16*m.b29*m.b37 - 192*
m.b16*m.b29*m.b38 - 128*m.b16*m.b29*m.b39 - 64*m.b16*m.b29*m.b40 - 352*m.b16*m.b30*m.b31 - 576*
m.b16*m.b30*m.b32 - 512*m.b16*m.b30*m.b33 - 448*m.b16*m.b30*m.b34 - 384*m.b16*m.b30*m.b35 - 320*
m.b16*m.b30*m.b36 - 256*m.b16*m.b30*m.b37 - 192*m.b16*m.b30*m.b38 - 128*m.b16*m.b30*m.b39 - 64*
m.b16*m.b30*m.b40 - 576*m.b16*m.b31*m.b32 - 512*m.b16*m.b31*m.b33 - 448*m.b16*m.b31*m.b34 - 384*
m.b16*m.b31*m.b35 - 320*m.b16*m.b31*m.b36 - 256*m.b16*m.b31*m.b37 - 192*m.b16*m.b31*m.b38 - 128*
m.b16*m.b31*m.b39 - 64*m.b16*m.b31*m.b40 - 512*m.b16*m.b32*m.b33 - 448*m.b16*m.b32*m.b34 - 384*
m.b16*m.b32*m.b35 - 320*m.b16*m.b32*m.b36 - 256*m.b16*m.b32*m.b37 - 192*m.b16*m.b32*m.b38 - 128*
m.b16*m.b32*m.b39 - 64*m.b16*m.b32*m.b40 - 448*m.b16*m.b33*m.b34 - 384*m.b16*m.b33*m.b35 - 320*
m.b16*m.b33*m.b36 - 256*m.b16*m.b33*m.b37 - 192*m.b16*m.b33*m.b38 - 128*m.b16*m.b33*m.b39 - 64*
m.b16*m.b33*m.b40 - 384*m.b16*m.b34*m.b35 - 320*m.b16*m.b34*m.b36 - 256*m.b16*m.b34*m.b37 - 192*
m.b16*m.b34*m.b38 - 128*m.b16*m.b34*m.b39 - 64*m.b16*m.b34*m.b40 - 320*m.b16*m.b35*m.b36 - 256*
m.b16*m.b35*m.b37 - 192*m.b16*m.b35*m.b38 - 128*m.b16*m.b35*m.b39 - 64*m.b16*m.b35*m.b40 - 256*
m.b16*m.b36*m.b37 - 192*m.b16*m.b36*m.b38 - 128*m.b16*m.b36*m.b39 - 64*m.b16*m.b36*m.b40 - 192*
m.b16*m.b37*m.b38 - 128*m.b16*m.b37*m.b39 - 64*m.b16*m.b37*m.b40 - 128*m.b16*m.b38*m.b39 - 64*
m.b16*m.b38*m.b40 - 64*m.b16*m.b39*m.b40 - 64*m.b17*m.b18*m.b19 - 96*m.b17*m.b18*m.b20 - 96*m.b17
*m.b18*m.b21 - 96*m.b17*m.b18*m.b22 - 96*m.b17*m.b18*m.b23 - 96*m.b17*m.b18*m.b24 - 96*m.b17*
m.b18*m.b25 - 352*m.b17*m.b18*m.b26 - 320*m.b17*m.b18*m.b27 - 288*m.b17*m.b18*m.b28 - 256*m.b17*
m.b18*m.b29 - 224*m.b17*m.b18*m.b30 - 192*m.b17*m.b18*m.b31 - 384*m.b17*m.b18*m.b32 - 544*m.b17*
m.b18*m.b33 - 448*m.b17*m.b18*m.b34 - 352*m.b17*m.b18*m.b35 - 288*m.b17*m.b18*m.b36 - 224*m.b17*
m.b18*m.b37 - 160*m.b17*m.b18*m.b38 - 96*m.b17*m.b18*m.b39 - 32*m.b17*m.b18*m.b40 - 96*m.b17*
m.b19*m.b20 - 64*m.b17*m.b19*m.b21 - 96*m.b17*m.b19*m.b22 - 96*m.b17*m.b19*m.b23 - 96*m.b17*m.b19
*m.b24 - 96*m.b17*m.b19*m.b25 - 384*m.b17*m.b19*m.b26 - 352*m.b17*m.b19*m.b27 - 320*m.b17*m.b19*
m.b28 - 288*m.b17*m.b19*m.b29 - 256*m.b17*m.b19*m.b30 - 448*m.b17*m.b19*m.b31 - 384*m.b17*m.b19*
m.b32 - 544*m.b17*m.b19*m.b33 - 448*m.b17*m.b19*m.b34 - 352*m.b17*m.b19*m.b35 - 256*m.b17*m.b19*
m.b36 - 192*m.b17*m.b19*m.b37 - 128*m.b17*m.b19*m.b38 - 64*m.b17*m.b19*m.b39 - 32*m.b17*m.b19*
m.b40 - 96*m.b17*m.b20*m.b21 - 96*m.b17*m.b20*m.b22 - 64*m.b17*m.b20*m.b23 - 96*m.b17*m.b20*m.b24
- 96*m.b17*m.b20*m.b25 - 96*m.b17*m.b20*m.b26 - 384*m.b17*m.b20*m.b27 - 352*m.b17*m.b20*m.b28 -
320*m.b17*m.b20*m.b29 - 512*m.b17*m.b20*m.b30 - 448*m.b17*m.b20*m.b31 - 384*m.b17*m.b20*m.b32 -
544*m.b17*m.b20*m.b33 - 448*m.b17*m.b20*m.b34 - 352*m.b17*m.b20*m.b35 - 256*m.b17*m.b20*m.b36 -
160*m.b17*m.b20*m.b37 - 96*m.b17*m.b20*m.b38 - 64*m.b17*m.b20*m.b39 - 32*m.b17*m.b20*m.b40 - 96*
m.b17*m.b21*m.b22 - 96*m.b17*m.b21*m.b23 - 96*m.b17*m.b21*m.b24 - 64*m.b17*m.b21*m.b25 - 96*m.b17
*m.b21*m.b26 - 416*m.b17*m.b21*m.b27 - 384*m.b17*m.b21*m.b28 - 576*m.b17*m.b21*m.b29 - 512*m.b17*
m.b21*m.b30 - 448*m.b17*m.b21*m.b31 - 384*m.b17*m.b21*m.b32 - 544*m.b17*m.b21*m.b33 - 448*m.b17*
m.b21*m.b34 - 352*m.b17*m.b21*m.b35 - 256*m.b17*m.b21*m.b36 - 160*m.b17*m.b21*m.b37 - 96*m.b17*
m.b21*m.b38 - 64*m.b17*m.b21*m.b39 - 32*m.b17*m.b21*m.b40 - 96*m.b17*m.b22*m.b23 - 96*m.b17*m.b22
*m.b24 - 96*m.b17*m.b22*m.b25 - 96*m.b17*m.b22*m.b26 - 64*m.b17*m.b22*m.b27 - 640*m.b17*m.b22*
m.b28 - 576*m.b17*m.b22*m.b29 - 512*m.b17*m.b22*m.b30 - 448*m.b17*m.b22*m.b31 - 384*m.b17*m.b22*
m.b32 - 544*m.b17*m.b22*m.b33 - 448*m.b17*m.b22*m.b34 - 352*m.b17*m.b22*m.b35 - 256*m.b17*m.b22*
m.b36 - 192*m.b17*m.b22*m.b37 - 128*m.b17*m.b22*m.b38 - 64*m.b17*m.b22*m.b39 - 32*m.b17*m.b22*
m.b40 - 96*m.b17*m.b23*m.b24 - 96*m.b17*m.b23*m.b25 - 96*m.b17*m.b23*m.b26 - 320*m.b17*m.b23*
m.b27 - 640*m.b17*m.b23*m.b28 - 544*m.b17*m.b23*m.b29 - 512*m.b17*m.b23*m.b30 - 448*m.b17*m.b23*
m.b31 - 384*m.b17*m.b23*m.b32 - 544*m.b17*m.b23*m.b33 - 448*m.b17*m.b23*m.b34 - 352*m.b17*m.b23*
m.b35 - 288*m.b17*m.b23*m.b36 - 224*m.b17*m.b23*m.b37 - 160*m.b17*m.b23*m.b38 - 96*m.b17*m.b23*
m.b39 - 32*m.b17*m.b23*m.b40 - 96*m.b17*m.b24*m.b25 - 320*m.b17*m.b24*m.b26 - 288*m.b17*m.b24*
m.b27 - 256*m.b17*m.b24*m.b28 - 576*m.b17*m.b24*m.b29 - 512*m.b17*m.b24*m.b30 - 416*m.b17*m.b24*
m.b31 - 384*m.b17*m.b24*m.b32 - 544*m.b17*m.b24*m.b33 - 448*m.b17*m.b24*m.b34 - 384*m.b17*m.b24*
m.b35 - 320*m.b17*m.b24*m.b36 - 256*m.b17*m.b24*m.b37 - 192*m.b17*m.b24*m.b38 - 128*m.b17*m.b24*
m.b39 - 64*m.b17*m.b24*m.b40 - 288*m.b17*m.b25*m.b26 - 256*m.b17*m.b25*m.b27 - 224*m.b17*m.b25*
m.b28 - 544*m.b17*m.b25*m.b29 - 480*m.b17*m.b25*m.b30 - 416*m.b17*m.b25*m.b31 - 352*m.b17*m.b25*
m.b32 - 256*m.b17*m.b25*m.b33 - 448*m.b17*m.b25*m.b34 - 384*m.b17*m.b25*m.b35 - 320*m.b17*m.b25*
m.b36 - 256*m.b17*m.b25*m.b37 - 192*m.b17*m.b25*m.b38 - 128*m.b17*m.b25*m.b39 - 64*m.b17*m.b25*
m.b40 - 224*m.b17*m.b26*m.b27 - 192*m.b17*m.b26*m.b28 - 160*m.b17*m.b26*m.b29 - 448*m.b17*m.b26*
m.b30 - 384*m.b17*m.b26*m.b31 - 320*m.b17*m.b26*m.b32 - 512*m.b17*m.b26*m.b33 - 448*m.b17*m.b26*
m.b34 - 192*m.b17*m.b26*m.b35 - 320*m.b17*m.b26*m.b36 - 256*m.b17*m.b26*m.b37 - 192*m.b17*m.b26*
m.b38 - 128*m.b17*m.b26*m.b39 - 64*m.b17*m.b26*m.b40 - 160*m.b17*m.b27*m.b28 - 128*m.b17*m.b27*
m.b29 - 416*m.b17*m.b27*m.b30 - 352*m.b17*m.b27*m.b31 - 320*m.b17*m.b27*m.b32 - 512*m.b17*m.b27*
m.b33 - 448*m.b17*m.b27*m.b34 - 384*m.b17*m.b27*m.b35 - 320*m.b17*m.b27*m.b36 - 128*m.b17*m.b27*
m.b37 - 192*m.b17*m.b27*m.b38 - 128*m.b17*m.b27*m.b39 - 64*m.b17*m.b27*m.b40 - 96*m.b17*m.b28*
m.b29 - 64*m.b17*m.b28*m.b30 - 352*m.b17*m.b28*m.b31 - 320*m.b17*m.b28*m.b32 - 512*m.b17*m.b28*
m.b33 - 448*m.b17*m.b28*m.b34 - 384*m.b17*m.b28*m.b35 - 320*m.b17*m.b28*m.b36 - 256*m.b17*m.b28*
m.b37 - 192*m.b17*m.b28*m.b38 - 64*m.b17*m.b28*m.b39 - 64*m.b17*m.b28*m.b40 - 64*m.b17*m.b29*
m.b30 - 352*m.b17*m.b29*m.b31 - 320*m.b17*m.b29*m.b32 - 512*m.b17*m.b29*m.b33 - 448*m.b17*m.b29*
m.b34 - 384*m.b17*m.b29*m.b35 - 320*m.b17*m.b29*m.b36 - 256*m.b17*m.b29*m.b37 - 192*m.b17*m.b29*
m.b38 - 128*m.b17*m.b29*m.b39 - 64*m.b17*m.b29*m.b40 - 64*m.b17*m.b30*m.b31 - 320*m.b17*m.b30*
m.b32 - 512*m.b17*m.b30*m.b33 - 448*m.b17*m.b30*m.b34 - 384*m.b17*m.b30*m.b35 - 320*m.b17*m.b30*
m.b36 - 256*m.b17*m.b30*m.b37 - 192*m.b17*m.b30*m.b38 - 128*m.b17*m.b30*m.b39 - 64*m.b17*m.b30*
m.b40 - 320*m.b17*m.b31*m.b32 - 512*m.b17*m.b31*m.b33 - 448*m.b17*m.b31*m.b34 - 384*m.b17*m.b31*
m.b35 - 320*m.b17*m.b31*m.b36 - 256*m.b17*m.b31*m.b37 - 192*m.b17*m.b31*m.b38 - 128*m.b17*m.b31*
m.b39 - 64*m.b17*m.b31*m.b40 - 512*m.b17*m.b32*m.b33 - 448*m.b17*m.b32*m.b34 - 384*m.b17*m.b32*
m.b35 - 320*m.b17*m.b32*m.b36 - 256*m.b17*m.b32*m.b37 - 192*m.b17*m.b32*m.b38 - 128*m.b17*m.b32*
m.b39 - 64*m.b17*m.b32*m.b40 - 448*m.b17*m.b33*m.b34 - 384*m.b17*m.b33*m.b35 - 320*m.b17*m.b33*
m.b36 - 256*m.b17*m.b33*m.b37 - 192*m.b17*m.b33*m.b38 - 128*m.b17*m.b33*m.b39 - 64*m.b17*m.b33*
m.b40 - 384*m.b17*m.b34*m.b35 - 320*m.b17*m.b34*m.b36 - 256*m.b17*m.b34*m.b37 - 192*m.b17*m.b34*
m.b38 - 128*m.b17*m.b34*m.b39 - 64*m.b17*m.b34*m.b40 - 320*m.b17*m.b35*m.b36 - 256*m.b17*m.b35*
m.b37 - 192*m.b17*m.b35*m.b38 - 128*m.b17*m.b35*m.b39 - 64*m.b17*m.b35*m.b40 - 256*m.b17*m.b36*
m.b37 - 192*m.b17*m.b36*m.b38 - 128*m.b17*m.b36*m.b39 - 64*m.b17*m.b36*m.b40 - 192*m.b17*m.b37*
m.b38 - 128*m.b17*m.b37*m.b39 - 64*m.b17*m.b37*m.b40 - 128*m.b17*m.b38*m.b39 - 64*m.b17*m.b38*
m.b40 - 64*m.b17*m.b39*m.b40 - 64*m.b18*m.b19*m.b20 - 96*m.b18*m.b19*m.b21 - 96*m.b18*m.b19*m.b22
- 96*m.b18*m.b19*m.b23 - 96*m.b18*m.b19*m.b24 - 96*m.b18*m.b19*m.b25 - 96*m.b18*m.b19*m.b26 -
384*m.b18*m.b19*m.b27 - 352*m.b18*m.b19*m.b28 - 320*m.b18*m.b19*m.b29 - 288*m.b18*m.b19*m.b30 -
256*m.b18*m.b19*m.b31 - 224*m.b18*m.b19*m.b32 - 384*m.b18*m.b19*m.b33 - 512*m.b18*m.b19*m.b34 -
416*m.b18*m.b19*m.b35 - 320*m.b18*m.b19*m.b36 - 224*m.b18*m.b19*m.b37 - 160*m.b18*m.b19*m.b38 -
96*m.b18*m.b19*m.b39 - 32*m.b18*m.b19*m.b40 - 96*m.b18*m.b20*m.b21 - 64*m.b18*m.b20*m.b22 - 96*
m.b18*m.b20*m.b23 - 96*m.b18*m.b20*m.b24 - 96*m.b18*m.b20*m.b25 - 96*m.b18*m.b20*m.b26 - 416*
m.b18*m.b20*m.b27 - 384*m.b18*m.b20*m.b28 - 352*m.b18*m.b20*m.b29 - 320*m.b18*m.b20*m.b30 - 288*
m.b18*m.b20*m.b31 - 448*m.b18*m.b20*m.b32 - 384*m.b18*m.b20*m.b33 - 512*m.b18*m.b20*m.b34 - 416*
m.b18*m.b20*m.b35 - 320*m.b18*m.b20*m.b36 - 224*m.b18*m.b20*m.b37 - 128*m.b18*m.b20*m.b38 - 64*
m.b18*m.b20*m.b39 - 32*m.b18*m.b20*m.b40 - 96*m.b18*m.b21*m.b22 - 96*m.b18*m.b21*m.b23 - 64*m.b18
*m.b21*m.b24 - 96*m.b18*m.b21*m.b25 - 96*m.b18*m.b21*m.b26 - 96*m.b18*m.b21*m.b27 - 416*m.b18*
m.b21*m.b28 - 384*m.b18*m.b21*m.b29 - 352*m.b18*m.b21*m.b30 - 512*m.b18*m.b21*m.b31 - 448*m.b18*
m.b21*m.b32 - 384*m.b18*m.b21*m.b33 - 512*m.b18*m.b21*m.b34 - 416*m.b18*m.b21*m.b35 - 320*m.b18*
m.b21*m.b36 - 224*m.b18*m.b21*m.b37 - 128*m.b18*m.b21*m.b38 - 64*m.b18*m.b21*m.b39 - 32*m.b18*
m.b21*m.b40 - 96*m.b18*m.b22*m.b23 - 96*m.b18*m.b22*m.b24 - 96*m.b18*m.b22*m.b25 - 64*m.b18*m.b22
*m.b26 - 96*m.b18*m.b22*m.b27 - 448*m.b18*m.b22*m.b28 - 416*m.b18*m.b22*m.b29 - 576*m.b18*m.b22*
m.b30 - 512*m.b18*m.b22*m.b31 - 448*m.b18*m.b22*m.b32 - 384*m.b18*m.b22*m.b33 - 512*m.b18*m.b22*
m.b34 - 416*m.b18*m.b22*m.b35 - 320*m.b18*m.b22*m.b36 - 224*m.b18*m.b22*m.b37 - 160*m.b18*m.b22*
m.b38 - 96*m.b18*m.b22*m.b39 - 32*m.b18*m.b22*m.b40 - 96*m.b18*m.b23*m.b24 - 96*m.b18*m.b23*m.b25
- 96*m.b18*m.b23*m.b26 - 96*m.b18*m.b23*m.b27 - 64*m.b18*m.b23*m.b28 - 640*m.b18*m.b23*m.b29 -
576*m.b18*m.b23*m.b30 - 512*m.b18*m.b23*m.b31 - 448*m.b18*m.b23*m.b32 - 384*m.b18*m.b23*m.b33 -
512*m.b18*m.b23*m.b34 - 416*m.b18*m.b23*m.b35 - 320*m.b18*m.b23*m.b36 - 256*m.b18*m.b23*m.b37 -
192*m.b18*m.b23*m.b38 - 128*m.b18*m.b23*m.b39 - 64*m.b18*m.b23*m.b40 - 96*m.b18*m.b24*m.b25 - 96*
m.b18*m.b24*m.b26 - 96*m.b18*m.b24*m.b27 - 288*m.b18*m.b24*m.b28 - 608*m.b18*m.b24*m.b29 - 512*
m.b18*m.b24*m.b30 - 480*m.b18*m.b24*m.b31 - 416*m.b18*m.b24*m.b32 - 352*m.b18*m.b24*m.b33 - 480*
m.b18*m.b24*m.b34 - 384*m.b18*m.b24*m.b35 - 320*m.b18*m.b24*m.b36 - 256*m.b18*m.b24*m.b37 - 192*
m.b18*m.b24*m.b38 - 128*m.b18*m.b24*m.b39 - 64*m.b18*m.b24*m.b40 - 96*m.b18*m.b25*m.b26 - 288*
m.b18*m.b25*m.b27 - 256*m.b18*m.b25*m.b28 - 224*m.b18*m.b25*m.b29 - 512*m.b18*m.b25*m.b30 - 448*
m.b18*m.b25*m.b31 - 352*m.b18*m.b25*m.b32 - 320*m.b18*m.b25*m.b33 - 448*m.b18*m.b25*m.b34 - 384*
m.b18*m.b25*m.b35 - 320*m.b18*m.b25*m.b36 - 256*m.b18*m.b25*m.b37 - 192*m.b18*m.b25*m.b38 - 128*
m.b18*m.b25*m.b39 - 64*m.b18*m.b25*m.b40 - 256*m.b18*m.b26*m.b27 - 224*m.b18*m.b26*m.b28 - 192*
m.b18*m.b26*m.b29 - 480*m.b18*m.b26*m.b30 - 416*m.b18*m.b26*m.b31 - 352*m.b18*m.b26*m.b32 - 288*
m.b18*m.b26*m.b33 - 224*m.b18*m.b26*m.b34 - 384*m.b18*m.b26*m.b35 - 320*m.b18*m.b26*m.b36 - 256*
m.b18*m.b26*m.b37 - 192*m.b18*m.b26*m.b38 - 128*m.b18*m.b26*m.b39 - 64*m.b18*m.b26*m.b40 - 192*
m.b18*m.b27*m.b28 - 160*m.b18*m.b27*m.b29 - 128*m.b18*m.b27*m.b30 - 384*m.b18*m.b27*m.b31 - 320*
m.b18*m.b27*m.b32 - 288*m.b18*m.b27*m.b33 - 448*m.b18*m.b27*m.b34 - 384*m.b18*m.b27*m.b35 - 160*
m.b18*m.b27*m.b36 - 256*m.b18*m.b27*m.b37 - 192*m.b18*m.b27*m.b38 - 128*m.b18*m.b27*m.b39 - 64*
m.b18*m.b27*m.b40 - 128*m.b18*m.b28*m.b29 - 96*m.b18*m.b28*m.b30 - 352*m.b18*m.b28*m.b31 - 320*
m.b18*m.b28*m.b32 - 288*m.b18*m.b28*m.b33 - 448*m.b18*m.b28*m.b34 - 384*m.b18*m.b28*m.b35 - 320*
m.b18*m.b28*m.b36 - 256*m.b18*m.b28*m.b37 - 96*m.b18*m.b28*m.b38 - 128*m.b18*m.b28*m.b39 - 64*
m.b18*m.b28*m.b40 - 64*m.b18*m.b29*m.b30 - 64*m.b18*m.b29*m.b31 - 320*m.b18*m.b29*m.b32 - 288*
m.b18*m.b29*m.b33 - 448*m.b18*m.b29*m.b34 - 384*m.b18*m.b29*m.b35 - 320*m.b18*m.b29*m.b36 - 256*
m.b18*m.b29*m.b37 - 192*m.b18*m.b29*m.b38 - 128*m.b18*m.b29*m.b39 - 32*m.b18*m.b29*m.b40 - 64*
m.b18*m.b30*m.b31 - 320*m.b18*m.b30*m.b32 - 288*m.b18*m.b30*m.b33 - 448*m.b18*m.b30*m.b34 - 384*
m.b18*m.b30*m.b35 - 320*m.b18*m.b30*m.b36 - 256*m.b18*m.b30*m.b37 - 192*m.b18*m.b30*m.b38 - 128*
m.b18*m.b30*m.b39 - 64*m.b18*m.b30*m.b40 - 64*m.b18*m.b31*m.b32 - 288*m.b18*m.b31*m.b33 - 448*
m.b18*m.b31*m.b34 - 384*m.b18*m.b31*m.b35 - 320*m.b18*m.b31*m.b36 - 256*m.b18*m.b31*m.b37 - 192*
m.b18*m.b31*m.b38 - 128*m.b18*m.b31*m.b39 - 64*m.b18*m.b31*m.b40 - 288*m.b18*m.b32*m.b33 - 448*
m.b18*m.b32*m.b34 - 384*m.b18*m.b32*m.b35 - 320*m.b18*m.b32*m.b36 - 256*m.b18*m.b32*m.b37 - 192*
m.b18*m.b32*m.b38 - 128*m.b18*m.b32*m.b39 - 64*m.b18*m.b32*m.b40 - 448*m.b18*m.b33*m.b34 - 384*
m.b18*m.b33*m.b35 - 320*m.b18*m.b33*m.b36 - 256*m.b18*m.b33*m.b37 - 192*m.b18*m.b33*m.b38 - 128*
m.b18*m.b33*m.b39 - 64*m.b18*m.b33*m.b40 - 384*m.b18*m.b34*m.b35 - 320*m.b18*m.b34*m.b36 - 256*
m.b18*m.b34*m.b37 - 192*m.b18*m.b34*m.b38 - 128*m.b18*m.b34*m.b39 - 64*m.b18*m.b34*m.b40 - 320*
m.b18*m.b35*m.b36 - 256*m.b18*m.b35*m.b37 - 192*m.b18*m.b35*m.b38 - 128*m.b18*m.b35*m.b39 - 64*
m.b18*m.b35*m.b40 - 256*m.b18*m.b36*m.b37 - 192*m.b18*m.b36*m.b38 - 128*m.b18*m.b36*m.b39 - 64*
m.b18*m.b36*m.b40 - 192*m.b18*m.b37*m.b38 - 128*m.b18*m.b37*m.b39 - 64*m.b18*m.b37*m.b40 - 128*
m.b18*m.b38*m.b39 - 64*m.b18*m.b38*m.b40 - 64*m.b18*m.b39*m.b40 - 64*m.b19*m.b20*m.b21 - 96*m.b19
*m.b20*m.b22 - 96*m.b19*m.b20*m.b23 - 96*m.b19*m.b20*m.b24 - 96*m.b19*m.b20*m.b25 - 96*m.b19*
m.b20*m.b26 - 96*m.b19*m.b20*m.b27 - 416*m.b19*m.b20*m.b28 - 384*m.b19*m.b20*m.b29 - 352*m.b19*
m.b20*m.b30 - 320*m.b19*m.b20*m.b31 - 288*m.b19*m.b20*m.b32 - 256*m.b19*m.b20*m.b33 - 384*m.b19*
m.b20*m.b34 - 480*m.b19*m.b20*m.b35 - 384*m.b19*m.b20*m.b36 - 288*m.b19*m.b20*m.b37 - 192*m.b19*
m.b20*m.b38 - 96*m.b19*m.b20*m.b39 - 32*m.b19*m.b20*m.b40 - 96*m.b19*m.b21*m.b22 - 64*m.b19*m.b21
*m.b23 - 96*m.b19*m.b21*m.b24 - 96*m.b19*m.b21*m.b25 - 96*m.b19*m.b21*m.b26 - 96*m.b19*m.b21*
m.b27 - 448*m.b19*m.b21*m.b28 - 416*m.b19*m.b21*m.b29 - 384*m.b19*m.b21*m.b30 - 352*m.b19*m.b21*
m.b31 - 320*m.b19*m.b21*m.b32 - 448*m.b19*m.b21*m.b33 - 384*m.b19*m.b21*m.b34 - 480*m.b19*m.b21*
m.b35 - 384*m.b19*m.b21*m.b36 - 288*m.b19*m.b21*m.b37 - 192*m.b19*m.b21*m.b38 - 96*m.b19*m.b21*
m.b39 - 32*m.b19*m.b21*m.b40 - 96*m.b19*m.b22*m.b23 - 96*m.b19*m.b22*m.b24 - 64*m.b19*m.b22*m.b25
- 96*m.b19*m.b22*m.b26 - 96*m.b19*m.b22*m.b27 - 96*m.b19*m.b22*m.b28 - 448*m.b19*m.b22*m.b29 -
416*m.b19*m.b22*m.b30 - 384*m.b19*m.b22*m.b31 - 512*m.b19*m.b22*m.b32 - 448*m.b19*m.b22*m.b33 -
384*m.b19*m.b22*m.b34 - 480*m.b19*m.b22*m.b35 - 384*m.b19*m.b22*m.b36 - 288*m.b19*m.b22*m.b37 -
192*m.b19*m.b22*m.b38 - 128*m.b19*m.b22*m.b39 - 64*m.b19*m.b22*m.b40 - 96*m.b19*m.b23*m.b24 - 96*
m.b19*m.b23*m.b25 - 96*m.b19*m.b23*m.b26 - 64*m.b19*m.b23*m.b27 - 96*m.b19*m.b23*m.b28 - 448*
m.b19*m.b23*m.b29 - 416*m.b19*m.b23*m.b30 - 544*m.b19*m.b23*m.b31 - 480*m.b19*m.b23*m.b32 - 416*
m.b19*m.b23*m.b33 - 352*m.b19*m.b23*m.b34 - 448*m.b19*m.b23*m.b35 - 352*m.b19*m.b23*m.b36 - 256*
m.b19*m.b23*m.b37 - 192*m.b19*m.b23*m.b38 - 128*m.b19*m.b23*m.b39 - 64*m.b19*m.b23*m.b40 - 96*
m.b19*m.b24*m.b25 - 96*m.b19*m.b24*m.b26 - 96*m.b19*m.b24*m.b27 - 96*m.b19*m.b24*m.b28 - 64*m.b19
*m.b24*m.b29 - 576*m.b19*m.b24*m.b30 - 512*m.b19*m.b24*m.b31 - 448*m.b19*m.b24*m.b32 - 384*m.b19*
m.b24*m.b33 - 320*m.b19*m.b24*m.b34 - 416*m.b19*m.b24*m.b35 - 320*m.b19*m.b24*m.b36 - 256*m.b19*
m.b24*m.b37 - 192*m.b19*m.b24*m.b38 - 128*m.b19*m.b24*m.b39 - 64*m.b19*m.b24*m.b40 - 96*m.b19*
m.b25*m.b26 - 96*m.b19*m.b25*m.b27 - 96*m.b19*m.b25*m.b28 - 256*m.b19*m.b25*m.b29 - 544*m.b19*
m.b25*m.b30 - 448*m.b19*m.b25*m.b31 - 416*m.b19*m.b25*m.b32 - 352*m.b19*m.b25*m.b33 - 288*m.b19*
m.b25*m.b34 - 384*m.b19*m.b25*m.b35 - 320*m.b19*m.b25*m.b36 - 256*m.b19*m.b25*m.b37 - 192*m.b19*
m.b25*m.b38 - 128*m.b19*m.b25*m.b39 - 64*m.b19*m.b25*m.b40 - 96*m.b19*m.b26*m.b27 - 256*m.b19*
m.b26*m.b28 - 224*m.b19*m.b26*m.b29 - 192*m.b19*m.b26*m.b30 - 448*m.b19*m.b26*m.b31 - 384*m.b19*
m.b26*m.b32 - 288*m.b19*m.b26*m.b33 - 256*m.b19*m.b26*m.b34 - 384*m.b19*m.b26*m.b35 - 320*m.b19*
m.b26*m.b36 - 256*m.b19*m.b26*m.b37 - 192*m.b19*m.b26*m.b38 - 128*m.b19*m.b26*m.b39 - 64*m.b19*
m.b26*m.b40 - 224*m.b19*m.b27*m.b28 - 192*m.b19*m.b27*m.b29 - 160*m.b19*m.b27*m.b30 - 416*m.b19*
m.b27*m.b31 - 352*m.b19*m.b27*m.b32 - 288*m.b19*m.b27*m.b33 - 256*m.b19*m.b27*m.b34 - 192*m.b19*
m.b27*m.b35 - 320*m.b19*m.b27*m.b36 - 256*m.b19*m.b27*m.b37 - 192*m.b19*m.b27*m.b38 - 128*m.b19*
m.b27*m.b39 - 64*m.b19*m.b27*m.b40 - 160*m.b19*m.b28*m.b29 - 128*m.b19*m.b28*m.b30 - 96*m.b19*
m.b28*m.b31 - 320*m.b19*m.b28*m.b32 - 288*m.b19*m.b28*m.b33 - 256*m.b19*m.b28*m.b34 - 384*m.b19*
m.b28*m.b35 - 320*m.b19*m.b28*m.b36 - 128*m.b19*m.b28*m.b37 - 192*m.b19*m.b28*m.b38 - 128*m.b19*
m.b28*m.b39 - 64*m.b19*m.b28*m.b40 - 96*m.b19*m.b29*m.b30 - 64*m.b19*m.b29*m.b31 - 320*m.b19*
m.b29*m.b32 - 288*m.b19*m.b29*m.b33 - 256*m.b19*m.b29*m.b34 - 384*m.b19*m.b29*m.b35 - 320*m.b19*
m.b29*m.b36 - 256*m.b19*m.b29*m.b37 - 192*m.b19*m.b29*m.b38 - 64*m.b19*m.b29*m.b39 - 64*m.b19*
m.b29*m.b40 - 64*m.b19*m.b30*m.b31 - 64*m.b19*m.b30*m.b32 - 288*m.b19*m.b30*m.b33 - 256*m.b19*
m.b30*m.b34 - 384*m.b19*m.b30*m.b35 - 320*m.b19*m.b30*m.b36 - 256*m.b19*m.b30*m.b37 - 192*m.b19*
m.b30*m.b38 - 128*m.b19*m.b30*m.b39 - 64*m.b19*m.b30*m.b40 - 64*m.b19*m.b31*m.b32 - 288*m.b19*
m.b31*m.b33 - 256*m.b19*m.b31*m.b34 - 384*m.b19*m.b31*m.b35 - 320*m.b19*m.b31*m.b36 - 256*m.b19*
m.b31*m.b37 - 192*m.b19*m.b31*m.b38 - 128*m.b19*m.b31*m.b39 - 64*m.b19*m.b31*m.b40 - 64*m.b19*
m.b32*m.b33 - 256*m.b19*m.b32*m.b34 - 384*m.b19*m.b32*m.b35 - 320*m.b19*m.b32*m.b36 - 256*m.b19*
m.b32*m.b37 - 192*m.b19*m.b32*m.b38 - 128*m.b19*m.b32*m.b39 - 64*m.b19*m.b32*m.b40 - 256*m.b19*
m.b33*m.b34 - 384*m.b19*m.b33*m.b35 - 320*m.b19*m.b33*m.b36 - 256*m.b19*m.b33*m.b37 - 192*m.b19*
m.b33*m.b38 - 128*m.b19*m.b33*m.b39 - 64*m.b19*m.b33*m.b40 - 384*m.b19*m.b34*m.b35 - 320*m.b19*
m.b34*m.b36 - 256*m.b19*m.b34*m.b37 - 192*m.b19*m.b34*m.b38 - 128*m.b19*m.b34*m.b39 - 64*m.b19*
m.b34*m.b40 - 320*m.b19*m.b35*m.b36 - 256*m.b19*m.b35*m.b37 - 192*m.b19*m.b35*m.b38 - 128*m.b19*
m.b35*m.b39 - 64*m.b19*m.b35*m.b40 - 256*m.b19*m.b36*m.b37 - 192*m.b19*m.b36*m.b38 - 128*m.b19*
m.b36*m.b39 - 64*m.b19*m.b36*m.b40 - 192*m.b19*m.b37*m.b38 - 128*m.b19*m.b37*m.b39 - 64*m.b19*
m.b37*m.b40 - 128*m.b19*m.b38*m.b39 - 64*m.b19*m.b38*m.b40 - 64*m.b19*m.b39*m.b40 - 64*m.b20*
m.b21*m.b22 - 96*m.b20*m.b21*m.b23 - 96*m.b20*m.b21*m.b24 - 96*m.b20*m.b21*m.b25 - 96*m.b20*m.b21
*m.b26 - 96*m.b20*m.b21*m.b27 - 96*m.b20*m.b21*m.b28 - 448*m.b20*m.b21*m.b29 - 416*m.b20*m.b21*
m.b30 - 384*m.b20*m.b21*m.b31 - 352*m.b20*m.b21*m.b32 - 320*m.b20*m.b21*m.b33 - 288*m.b20*m.b21*
m.b34 - 384*m.b20*m.b21*m.b35 - 448*m.b20*m.b21*m.b36 - 352*m.b20*m.b21*m.b37 - 256*m.b20*m.b21*
m.b38 - 160*m.b20*m.b21*m.b39 - 64*m.b20*m.b21*m.b40 - 96*m.b20*m.b22*m.b23 - 64*m.b20*m.b22*
m.b24 - 96*m.b20*m.b22*m.b25 - 96*m.b20*m.b22*m.b26 - 96*m.b20*m.b22*m.b27 - 96*m.b20*m.b22*m.b28
- 448*m.b20*m.b22*m.b29 - 416*m.b20*m.b22*m.b30 - 384*m.b20*m.b22*m.b31 - 352*m.b20*m.b22*m.b32
- 320*m.b20*m.b22*m.b33 - 416*m.b20*m.b22*m.b34 - 352*m.b20*m.b22*m.b35 - 416*m.b20*m.b22*m.b36
- 320*m.b20*m.b22*m.b37 - 224*m.b20*m.b22*m.b38 - 128*m.b20*m.b22*m.b39 - 64*m.b20*m.b22*m.b40
- 96*m.b20*m.b23*m.b24 - 96*m.b20*m.b23*m.b25 - 64*m.b20*m.b23*m.b26 - 96*m.b20*m.b23*m.b27 - 96
*m.b20*m.b23*m.b28 - 96*m.b20*m.b23*m.b29 - 416*m.b20*m.b23*m.b30 - 384*m.b20*m.b23*m.b31 - 352*
m.b20*m.b23*m.b32 - 448*m.b20*m.b23*m.b33 - 384*m.b20*m.b23*m.b34 - 320*m.b20*m.b23*m.b35 - 384*
m.b20*m.b23*m.b36 - 288*m.b20*m.b23*m.b37 - 192*m.b20*m.b23*m.b38 - 128*m.b20*m.b23*m.b39 - 64*
m.b20*m.b23*m.b40 - 96*m.b20*m.b24*m.b25 - 96*m.b20*m.b24*m.b26 - 96*m.b20*m.b24*m.b27 - 64*m.b20
*m.b24*m.b28 - 96*m.b20*m.b24*m.b29 - 416*m.b20*m.b24*m.b30 - 384*m.b20*m.b24*m.b31 - 480*m.b20*
m.b24*m.b32 - 416*m.b20*m.b24*m.b33 - 352*m.b20*m.b24*m.b34 - 288*m.b20*m.b24*m.b35 - 352*m.b20*
m.b24*m.b36 - 256*m.b20*m.b24*m.b37 - 192*m.b20*m.b24*m.b38 - 128*m.b20*m.b24*m.b39 - 64*m.b20*
m.b24*m.b40 - 96*m.b20*m.b25*m.b26 - 96*m.b20*m.b25*m.b27 - 96*m.b20*m.b25*m.b28 - 96*m.b20*m.b25
*m.b29 - 64*m.b20*m.b25*m.b30 - 512*m.b20*m.b25*m.b31 - 448*m.b20*m.b25*m.b32 - 384*m.b20*m.b25*
m.b33 - 320*m.b20*m.b25*m.b34 - 256*m.b20*m.b25*m.b35 - 320*m.b20*m.b25*m.b36 - 256*m.b20*m.b25*
m.b37 - 192*m.b20*m.b25*m.b38 - 128*m.b20*m.b25*m.b39 - 64*m.b20*m.b25*m.b40 - 96*m.b20*m.b26*
m.b27 - 96*m.b20*m.b26*m.b28 - 96*m.b20*m.b26*m.b29 - 224*m.b20*m.b26*m.b30 - 480*m.b20*m.b26*
m.b31 - 384*m.b20*m.b26*m.b32 - 352*m.b20*m.b26*m.b33 - 288*m.b20*m.b26*m.b34 - 224*m.b20*m.b26*
m.b35 - 320*m.b20*m.b26*m.b36 - 256*m.b20*m.b26*m.b37 - 192*m.b20*m.b26*m.b38 - 128*m.b20*m.b26*
m.b39 - 64*m.b20*m.b26*m.b40 - 96*m.b20*m.b27*m.b28 - 224*m.b20*m.b27*m.b29 - 192*m.b20*m.b27*
m.b30 - 160*m.b20*m.b27*m.b31 - 384*m.b20*m.b27*m.b32 - 320*m.b20*m.b27*m.b33 - 224*m.b20*m.b27*
m.b34 - 224*m.b20*m.b27*m.b35 - 320*m.b20*m.b27*m.b36 - 256*m.b20*m.b27*m.b37 - 192*m.b20*m.b27*
m.b38 - 128*m.b20*m.b27*m.b39 - 64*m.b20*m.b27*m.b40 - 192*m.b20*m.b28*m.b29 - 160*m.b20*m.b28*
m.b30 - 128*m.b20*m.b28*m.b31 - 352*m.b20*m.b28*m.b32 - 288*m.b20*m.b28*m.b33 - 256*m.b20*m.b28*
m.b34 - 224*m.b20*m.b28*m.b35 - 160*m.b20*m.b28*m.b36 - 256*m.b20*m.b28*m.b37 - 192*m.b20*m.b28*
m.b38 - 128*m.b20*m.b28*m.b39 - 64*m.b20*m.b28*m.b40 - 128*m.b20*m.b29*m.b30 - 96*m.b20*m.b29*
m.b31 - 64*m.b20*m.b29*m.b32 - 288*m.b20*m.b29*m.b33 - 256*m.b20*m.b29*m.b34 - 224*m.b20*m.b29*
m.b35 - 320*m.b20*m.b29*m.b36 - 256*m.b20*m.b29*m.b37 - 96*m.b20*m.b29*m.b38 - 128*m.b20*m.b29*
m.b39 - 64*m.b20*m.b29*m.b40 - 64*m.b20*m.b30*m.b31 - 64*m.b20*m.b30*m.b32 - 288*m.b20*m.b30*
m.b33 - 256*m.b20*m.b30*m.b34 - 224*m.b20*m.b30*m.b35 - 320*m.b20*m.b30*m.b36 - 256*m.b20*m.b30*
m.b37 - 192*m.b20*m.b30*m.b38 - 128*m.b20*m.b30*m.b39 - 32*m.b20*m.b30*m.b40 - 64*m.b20*m.b31*
m.b32 - 64*m.b20*m.b31*m.b33 - 256*m.b20*m.b31*m.b34 - 224*m.b20*m.b31*m.b35 - 320*m.b20*m.b31*
m.b36 - 256*m.b20*m.b31*m.b37 - 192*m.b20*m.b31*m.b38 - 128*m.b20*m.b31*m.b39 - 64*m.b20*m.b31*
m.b40 - 64*m.b20*m.b32*m.b33 - 256*m.b20*m.b32*m.b34 - 224*m.b20*m.b32*m.b35 - 320*m.b20*m.b32*
m.b36 - 256*m.b20*m.b32*m.b37 - 192*m.b20*m.b32*m.b38 - 128*m.b20*m.b32*m.b39 - 64*m.b20*m.b32*
m.b40 - 64*m.b20*m.b33*m.b34 - 224*m.b20*m.b33*m.b35 - 320*m.b20*m.b33*m.b36 - 256*m.b20*m.b33*
m.b37 - 192*m.b20*m.b33*m.b38 - 128*m.b20*m.b33*m.b39 - 64*m.b20*m.b33*m.b40 - 224*m.b20*m.b34*
m.b35 - 320*m.b20*m.b34*m.b36 - 256*m.b20*m.b34*m.b37 - 192*m.b20*m.b34*m.b38 - 128*m.b20*m.b34*
m.b39 - 64*m.b20*m.b34*m.b40 - 320*m.b20*m.b35*m.b36 - 256*m.b20*m.b35*m.b37 - 192*m.b20*m.b35*
m.b38 - 128*m.b20*m.b35*m.b39 - 64*m.b20*m.b35*m.b40 - 256*m.b20*m.b36*m.b37 - 192*m.b20*m.b36*
m.b38 - 128*m.b20*m.b36*m.b39 - 64*m.b20*m.b36*m.b40 - 192*m.b20*m.b37*m.b38 - 128*m.b20*m.b37*
m.b39 - 64*m.b20*m.b37*m.b40 - 128*m.b20*m.b38*m.b39 - 64*m.b20*m.b38*m.b40 - 64*m.b20*m.b39*
m.b40 - 64*m.b21*m.b22*m.b23 - 96*m.b21*m.b22*m.b24 - 96*m.b21*m.b22*m.b25 - 96*m.b21*m.b22*m.b26
- 96*m.b21*m.b22*m.b27 - 96*m.b21*m.b22*m.b28 - 96*m.b21*m.b22*m.b29 - 416*m.b21*m.b22*m.b30 -
384*m.b21*m.b22*m.b31 - 352*m.b21*m.b22*m.b32 - 320*m.b21*m.b22*m.b33 - 288*m.b21*m.b22*m.b34 -
256*m.b21*m.b22*m.b35 - 320*m.b21*m.b22*m.b36 - 352*m.b21*m.b22*m.b37 - 256*m.b21*m.b22*m.b38 -
160*m.b21*m.b22*m.b39 - 64*m.b21*m.b22*m.b40 - 96*m.b21*m.b23*m.b24 - 64*m.b21*m.b23*m.b25 - 96*
m.b21*m.b23*m.b26 - 96*m.b21*m.b23*m.b27 - 96*m.b21*m.b23*m.b28 - 96*m.b21*m.b23*m.b29 - 416*
m.b21*m.b23*m.b30 - 384*m.b21*m.b23*m.b31 - 352*m.b21*m.b23*m.b32 - 320*m.b21*m.b23*m.b33 - 288*
m.b21*m.b23*m.b34 - 352*m.b21*m.b23*m.b35 - 288*m.b21*m.b23*m.b36 - 320*m.b21*m.b23*m.b37 - 224*
m.b21*m.b23*m.b38 - 128*m.b21*m.b23*m.b39 - 64*m.b21*m.b23*m.b40 - 96*m.b21*m.b24*m.b25 - 96*
m.b21*m.b24*m.b26 - 64*m.b21*m.b24*m.b27 - 96*m.b21*m.b24*m.b28 - 96*m.b21*m.b24*m.b29 - 96*m.b21
*m.b24*m.b30 - 384*m.b21*m.b24*m.b31 - 352*m.b21*m.b24*m.b32 - 320*m.b21*m.b24*m.b33 - 384*m.b21*
m.b24*m.b34 - 320*m.b21*m.b24*m.b35 - 256*m.b21*m.b24*m.b36 - 288*m.b21*m.b24*m.b37 - 192*m.b21*
m.b24*m.b38 - 128*m.b21*m.b24*m.b39 - 64*m.b21*m.b24*m.b40 - 96*m.b21*m.b25*m.b26 - 96*m.b21*
m.b25*m.b27 - 96*m.b21*m.b25*m.b28 - 64*m.b21*m.b25*m.b29 - 96*m.b21*m.b25*m.b30 - 384*m.b21*
m.b25*m.b31 - 352*m.b21*m.b25*m.b32 - 416*m.b21*m.b25*m.b33 - 352*m.b21*m.b25*m.b34 - 288*m.b21*
m.b25*m.b35 - 224*m.b21*m.b25*m.b36 - 256*m.b21*m.b25*m.b37 - 192*m.b21*m.b25*m.b38 - 128*m.b21*
m.b25*m.b39 - 64*m.b21*m.b25*m.b40 - 96*m.b21*m.b26*m.b27 - 96*m.b21*m.b26*m.b28 - 96*m.b21*m.b26
*m.b29 - 96*m.b21*m.b26*m.b30 - 64*m.b21*m.b26*m.b31 - 448*m.b21*m.b26*m.b32 - 384*m.b21*m.b26*
m.b33 - 320*m.b21*m.b26*m.b34 - 256*m.b21*m.b26*m.b35 - 192*m.b21*m.b26*m.b36 - 256*m.b21*m.b26*
m.b37 - 192*m.b21*m.b26*m.b38 - 128*m.b21*m.b26*m.b39 - 64*m.b21*m.b26*m.b40 - 96*m.b21*m.b27*
m.b28 - 96*m.b21*m.b27*m.b29 - 96*m.b21*m.b27*m.b30 - 192*m.b21*m.b27*m.b31 - 416*m.b21*m.b27*
m.b32 - 320*m.b21*m.b27*m.b33 - 288*m.b21*m.b27*m.b34 - 224*m.b21*m.b27*m.b35 - 192*m.b21*m.b27*
m.b36 - 256*m.b21*m.b27*m.b37 - 192*m.b21*m.b27*m.b38 - 128*m.b21*m.b27*m.b39 - 64*m.b21*m.b27*
m.b40 - 96*m.b21*m.b28*m.b29 - 192*m.b21*m.b28*m.b30 - 160*m.b21*m.b28*m.b31 - 128*m.b21*m.b28*
m.b32 - 320*m.b21*m.b28*m.b33 - 256*m.b21*m.b28*m.b34 - 192*m.b21*m.b28*m.b35 - 192*m.b21*m.b28*
m.b36 - 256*m.b21*m.b28*m.b37 - 192*m.b21*m.b28*m.b38 - 128*m.b21*m.b28*m.b39 - 64*m.b21*m.b28*
m.b40 - 160*m.b21*m.b29*m.b30 - 128*m.b21*m.b29*m.b31 - 96*m.b21*m.b29*m.b32 - 288*m.b21*m.b29*
m.b33 - 256*m.b21*m.b29*m.b34 - 224*m.b21*m.b29*m.b35 - 192*m.b21*m.b29*m.b36 - 128*m.b21*m.b29*
m.b37 - 192*m.b21*m.b29*m.b38 - 128*m.b21*m.b29*m.b39 - 64*m.b21*m.b29*m.b40 - 96*m.b21*m.b30*
m.b31 - 64*m.b21*m.b30*m.b32 - 64*m.b21*m.b30*m.b33 - 256*m.b21*m.b30*m.b34 - 224*m.b21*m.b30*
m.b35 - 192*m.b21*m.b30*m.b36 - 256*m.b21*m.b30*m.b37 - 192*m.b21*m.b30*m.b38 - 64*m.b21*m.b30*
m.b39 - 64*m.b21*m.b30*m.b40 - 64*m.b21*m.b31*m.b32 - 64*m.b21*m.b31*m.b33 - 256*m.b21*m.b31*
m.b34 - 224*m.b21*m.b31*m.b35 - 192*m.b21*m.b31*m.b36 - 256*m.b21*m.b31*m.b37 - 192*m.b21*m.b31*
m.b38 - 128*m.b21*m.b31*m.b39 - 64*m.b21*m.b31*m.b40 - 64*m.b21*m.b32*m.b33 - 64*m.b21*m.b32*
m.b34 - 224*m.b21*m.b32*m.b35 - 192*m.b21*m.b32*m.b36 - 256*m.b21*m.b32*m.b37 - 192*m.b21*m.b32*
m.b38 - 128*m.b21*m.b32*m.b39 - 64*m.b21*m.b32*m.b40 - 64*m.b21*m.b33*m.b34 - 224*m.b21*m.b33*
m.b35 - 192*m.b21*m.b33*m.b36 - 256*m.b21*m.b33*m.b37 - 192*m.b21*m.b33*m.b38 - 128*m.b21*m.b33*
m.b39 - 64*m.b21*m.b33*m.b40 - 64*m.b21*m.b34*m.b35 - 192*m.b21*m.b34*m.b36 - 256*m.b21*m.b34*
m.b37 - 192*m.b21*m.b34*m.b38 - 128*m.b21*m.b34*m.b39 - 64*m.b21*m.b34*m.b40 - 192*m.b21*m.b35*
m.b36 - 256*m.b21*m.b35*m.b37 - 192*m.b21*m.b35*m.b38 - 128*m.b21*m.b35*m.b39 - 64*m.b21*m.b35*
m.b40 - 256*m.b21*m.b36*m.b37 - 192*m.b21*m.b36*m.b38 - 128*m.b21*m.b36*m.b39 - 64*m.b21*m.b36*
m.b40 - 192*m.b21*m.b37*m.b38 - 128*m.b21*m.b37*m.b39 - 64*m.b21*m.b37*m.b40 - 128*m.b21*m.b38*
m.b39 - 64*m.b21*m.b38*m.b40 - 64*m.b21*m.b39*m.b40 - 64*m.b22*m.b23*m.b24 - 96*m.b22*m.b23*m.b25
- 96*m.b22*m.b23*m.b26 - 96*m.b22*m.b23*m.b27 - 96*m.b22*m.b23*m.b28 - 96*m.b22*m.b23*m.b29 - 96
*m.b22*m.b23*m.b30 - 384*m.b22*m.b23*m.b31 - 352*m.b22*m.b23*m.b32 - 320*m.b22*m.b23*m.b33 - 288*
m.b22*m.b23*m.b34 - 256*m.b22*m.b23*m.b35 - 224*m.b22*m.b23*m.b36 - 256*m.b22*m.b23*m.b37 - 256*
m.b22*m.b23*m.b38 - 160*m.b22*m.b23*m.b39 - 64*m.b22*m.b23*m.b40 - 96*m.b22*m.b24*m.b25 - 64*
m.b22*m.b24*m.b26 - 96*m.b22*m.b24*m.b27 - 96*m.b22*m.b24*m.b28 - 96*m.b22*m.b24*m.b29 - 96*m.b22
*m.b24*m.b30 - 384*m.b22*m.b24*m.b31 - 352*m.b22*m.b24*m.b32 - 320*m.b22*m.b24*m.b33 - 288*m.b22*
m.b24*m.b34 - 256*m.b22*m.b24*m.b35 - 288*m.b22*m.b24*m.b36 - 224*m.b22*m.b24*m.b37 - 224*m.b22*
m.b24*m.b38 - 128*m.b22*m.b24*m.b39 - 64*m.b22*m.b24*m.b40 - 96*m.b22*m.b25*m.b26 - 96*m.b22*
m.b25*m.b27 - 64*m.b22*m.b25*m.b28 - 96*m.b22*m.b25*m.b29 - 96*m.b22*m.b25*m.b30 - 96*m.b22*m.b25
*m.b31 - 352*m.b22*m.b25*m.b32 - 320*m.b22*m.b25*m.b33 - 288*m.b22*m.b25*m.b34 - 320*m.b22*m.b25*
m.b35 - 256*m.b22*m.b25*m.b36 - 192*m.b22*m.b25*m.b37 - 192*m.b22*m.b25*m.b38 - 128*m.b22*m.b25*
m.b39 - 64*m.b22*m.b25*m.b40 - 96*m.b22*m.b26*m.b27 - 96*m.b22*m.b26*m.b28 - 96*m.b22*m.b26*m.b29
- 64*m.b22*m.b26*m.b30 - 96*m.b22*m.b26*m.b31 - 352*m.b22*m.b26*m.b32 - 320*m.b22*m.b26*m.b33 -
352*m.b22*m.b26*m.b34 - 288*m.b22*m.b26*m.b35 - 224*m.b22*m.b26*m.b36 - 160*m.b22*m.b26*m.b37 -
192*m.b22*m.b26*m.b38 - 128*m.b22*m.b26*m.b39 - 64*m.b22*m.b26*m.b40 - 96*m.b22*m.b27*m.b28 - 96*
m.b22*m.b27*m.b29 - 96*m.b22*m.b27*m.b30 - 96*m.b22*m.b27*m.b31 - 64*m.b22*m.b27*m.b32 - 384*
m.b22*m.b27*m.b33 - 320*m.b22*m.b27*m.b34 - 256*m.b22*m.b27*m.b35 - 192*m.b22*m.b27*m.b36 - 160*
m.b22*m.b27*m.b37 - 192*m.b22*m.b27*m.b38 - 128*m.b22*m.b27*m.b39 - 64*m.b22*m.b27*m.b40 - 96*
m.b22*m.b28*m.b29 - 96*m.b22*m.b28*m.b30 - 96*m.b22*m.b28*m.b31 - 160*m.b22*m.b28*m.b32 - 352*
m.b22*m.b28*m.b33 - 256*m.b22*m.b28*m.b34 - 224*m.b22*m.b28*m.b35 - 192*m.b22*m.b28*m.b36 - 160*
m.b22*m.b28*m.b37 - 192*m.b22*m.b28*m.b38 - 128*m.b22*m.b28*m.b39 - 64*m.b22*m.b28*m.b40 - 96*
m.b22*m.b29*m.b30 - 160*m.b22*m.b29*m.b31 - 128*m.b22*m.b29*m.b32 - 96*m.b22*m.b29*m.b33 - 256*
m.b22*m.b29*m.b34 - 224*m.b22*m.b29*m.b35 - 160*m.b22*m.b29*m.b36 - 160*m.b22*m.b29*m.b37 - 192*
m.b22*m.b29*m.b38 - 128*m.b22*m.b29*m.b39 - 64*m.b22*m.b29*m.b40 - 128*m.b22*m.b30*m.b31 - 96*
m.b22*m.b30*m.b32 - 64*m.b22*m.b30*m.b33 - 256*m.b22*m.b30*m.b34 - 224*m.b22*m.b30*m.b35 - 192*
m.b22*m.b30*m.b36 - 160*m.b22*m.b30*m.b37 - 96*m.b22*m.b30*m.b38 - 128*m.b22*m.b30*m.b39 - 64*
m.b22*m.b30*m.b40 - 64*m.b22*m.b31*m.b32 - 64*m.b22*m.b31*m.b33 - 64*m.b22*m.b31*m.b34 - 224*
m.b22*m.b31*m.b35 - 192*m.b22*m.b31*m.b36 - 160*m.b22*m.b31*m.b37 - 192*m.b22*m.b31*m.b38 - 128*
m.b22*m.b31*m.b39 - 32*m.b22*m.b31*m.b40 - 64*m.b22*m.b32*m.b33 - 64*m.b22*m.b32*m.b34 - 224*
m.b22*m.b32*m.b35 - 192*m.b22*m.b32*m.b36 - 160*m.b22*m.b32*m.b37 - 192*m.b22*m.b32*m.b38 - 128*
m.b22*m.b32*m.b39 - 64*m.b22*m.b32*m.b40 - 64*m.b22*m.b33*m.b34 - 64*m.b22*m.b33*m.b35 - 192*
m.b22*m.b33*m.b36 - 160*m.b22*m.b33*m.b37 - 192*m.b22*m.b33*m.b38 - 128*m.b22*m.b33*m.b39 - 64*
m.b22*m.b33*m.b40 - 64*m.b22*m.b34*m.b35 - 192*m.b22*m.b34*m.b36 - 160*m.b22*m.b34*m.b37 - 192*
m.b22*m.b34*m.b38 - 128*m.b22*m.b34*m.b39 - 64*m.b22*m.b34*m.b40 - 64*m.b22*m.b35*m.b36 - 160*
m.b22*m.b35*m.b37 - 192*m.b22*m.b35*m.b38 - 128*m.b22*m.b35*m.b39 - 64*m.b22*m.b35*m.b40 - 160*
m.b22*m.b36*m.b37 - 192*m.b22*m.b36*m.b38 - 128*m.b22*m.b36*m.b39 - 64*m.b22*m.b36*m.b40 - 192*
m.b22*m.b37*m.b38 - 128*m.b22*m.b37*m.b39 - 64*m.b22*m.b37*m.b40 - 128*m.b22*m.b38*m.b39 - 64*
m.b22*m.b38*m.b40 - 64*m.b22*m.b39*m.b40 - 64*m.b23*m.b24*m.b25 - 96*m.b23*m.b24*m.b26 - 96*m.b23
*m.b24*m.b27 - 96*m.b23*m.b24*m.b28 - 96*m.b23*m.b24*m.b29 - 96*m.b23*m.b24*m.b30 - 96*m.b23*
m.b24*m.b31 - 352*m.b23*m.b24*m.b32 - 320*m.b23*m.b24*m.b33 - 288*m.b23*m.b24*m.b34 - 256*m.b23*
m.b24*m.b35 - 224*m.b23*m.b24*m.b36 - 192*m.b23*m.b24*m.b37 - 192*m.b23*m.b24*m.b38 - 160*m.b23*
m.b24*m.b39 - 64*m.b23*m.b24*m.b40 - 96*m.b23*m.b25*m.b26 - 64*m.b23*m.b25*m.b27 - 96*m.b23*m.b25
*m.b28 - 96*m.b23*m.b25*m.b29 - 96*m.b23*m.b25*m.b30 - 96*m.b23*m.b25*m.b31 - 352*m.b23*m.b25*
m.b32 - 320*m.b23*m.b25*m.b33 - 288*m.b23*m.b25*m.b34 - 256*m.b23*m.b25*m.b35 - 224*m.b23*m.b25*
m.b36 - 224*m.b23*m.b25*m.b37 - 160*m.b23*m.b25*m.b38 - 128*m.b23*m.b25*m.b39 - 64*m.b23*m.b25*
m.b40 - 96*m.b23*m.b26*m.b27 - 96*m.b23*m.b26*m.b28 - 64*m.b23*m.b26*m.b29 - 96*m.b23*m.b26*m.b30
- 96*m.b23*m.b26*m.b31 - 96*m.b23*m.b26*m.b32 - 320*m.b23*m.b26*m.b33 - 288*m.b23*m.b26*m.b34 -
256*m.b23*m.b26*m.b35 - 256*m.b23*m.b26*m.b36 - 192*m.b23*m.b26*m.b37 - 128*m.b23*m.b26*m.b38 -
128*m.b23*m.b26*m.b39 - 64*m.b23*m.b26*m.b40 - 96*m.b23*m.b27*m.b28 - 96*m.b23*m.b27*m.b29 - 96*
m.b23*m.b27*m.b30 - 64*m.b23*m.b27*m.b31 - 96*m.b23*m.b27*m.b32 - 320*m.b23*m.b27*m.b33 - 288*
m.b23*m.b27*m.b34 - 288*m.b23*m.b27*m.b35 - 224*m.b23*m.b27*m.b36 - 160*m.b23*m.b27*m.b37 - 128*
m.b23*m.b27*m.b38 - 128*m.b23*m.b27*m.b39 - 64*m.b23*m.b27*m.b40 - 96*m.b23*m.b28*m.b29 - 96*
m.b23*m.b28*m.b30 - 96*m.b23*m.b28*m.b31 - 96*m.b23*m.b28*m.b32 - 64*m.b23*m.b28*m.b33 - 320*
m.b23*m.b28*m.b34 - 256*m.b23*m.b28*m.b35 - 192*m.b23*m.b28*m.b36 - 160*m.b23*m.b28*m.b37 - 128*
m.b23*m.b28*m.b38 - 128*m.b23*m.b28*m.b39 - 64*m.b23*m.b28*m.b40 - 96*m.b23*m.b29*m.b30 - 96*
m.b23*m.b29*m.b31 - 96*m.b23*m.b29*m.b32 - 128*m.b23*m.b29*m.b33 - 288*m.b23*m.b29*m.b34 - 192*
m.b23*m.b29*m.b35 - 192*m.b23*m.b29*m.b36 - 160*m.b23*m.b29*m.b37 - 128*m.b23*m.b29*m.b38 - 128*
m.b23*m.b29*m.b39 - 64*m.b23*m.b29*m.b40 - 96*m.b23*m.b30*m.b31 - 128*m.b23*m.b30*m.b32 - 96*
m.b23*m.b30*m.b33 - 64*m.b23*m.b30*m.b34 - 224*m.b23*m.b30*m.b35 - 192*m.b23*m.b30*m.b36 - 128*
m.b23*m.b30*m.b37 - 128*m.b23*m.b30*m.b38 - 128*m.b23*m.b30*m.b39 - 64*m.b23*m.b30*m.b40 - 96*
m.b23*m.b31*m.b32 - 64*m.b23*m.b31*m.b33 - 64*m.b23*m.b31*m.b34 - 224*m.b23*m.b31*m.b35 - 192*
m.b23*m.b31*m.b36 - 160*m.b23*m.b31*m.b37 - 128*m.b23*m.b31*m.b38 - 64*m.b23*m.b31*m.b39 - 64*
m.b23*m.b31*m.b40 - 64*m.b23*m.b32*m.b33 - 64*m.b23*m.b32*m.b34 - 64*m.b23*m.b32*m.b35 - 192*
m.b23*m.b32*m.b36 - 160*m.b23*m.b32*m.b37 - 128*m.b23*m.b32*m.b38 - 128*m.b23*m.b32*m.b39 - 64*
m.b23*m.b32*m.b40 - 64*m.b23*m.b33*m.b34 - 64*m.b23*m.b33*m.b35 - 192*m.b23*m.b33*m.b36 - 160*
m.b23*m.b33*m.b37 - 128*m.b23*m.b33*m.b38 - 128*m.b23*m.b33*m.b39 - 64*m.b23*m.b33*m.b40 - 64*
m.b23*m.b34*m.b35 - 64*m.b23*m.b34*m.b36 - 160*m.b23*m.b34*m.b37 - 128*m.b23*m.b34*m.b38 - 128*
m.b23*m.b34*m.b39 - 64*m.b23*m.b34*m.b40 - 64*m.b23*m.b35*m.b36 - 160*m.b23*m.b35*m.b37 - 128*
m.b23*m.b35*m.b38 - 128*m.b23*m.b35*m.b39 - 64*m.b23*m.b35*m.b40 - 64*m.b23*m.b36*m.b37 - 128*
m.b23*m.b36*m.b38 - 128*m.b23*m.b36*m.b39 - 64*m.b23*m.b36*m.b40 - 128*m.b23*m.b37*m.b38 - 128*
m.b23*m.b37*m.b39 - 64*m.b23*m.b37*m.b40 - 128*m.b23*m.b38*m.b39 - 64*m.b23*m.b38*m.b40 - 64*
m.b23*m.b39*m.b40 - 64*m.b24*m.b25*m.b26 - 96*m.b24*m.b25*m.b27 - 96*m.b24*m.b25*m.b28 - 96*m.b24
*m.b25*m.b29 - 96*m.b24*m.b25*m.b30 - 96*m.b24*m.b25*m.b31 - 96*m.b24*m.b25*m.b32 - 320*m.b24*
m.b25*m.b33 - 288*m.b24*m.b25*m.b34 - 256*m.b24*m.b25*m.b35 - 224*m.b24*m.b25*m.b36 - 192*m.b24*
m.b25*m.b37 - 160*m.b24*m.b25*m.b38 - 128*m.b24*m.b25*m.b39 - 64*m.b24*m.b25*m.b40 - 96*m.b24*
m.b26*m.b27 - 64*m.b24*m.b26*m.b28 - 96*m.b24*m.b26*m.b29 - 96*m.b24*m.b26*m.b30 - 96*m.b24*m.b26
*m.b31 - 96*m.b24*m.b26*m.b32 - 320*m.b24*m.b26*m.b33 - 288*m.b24*m.b26*m.b34 - 256*m.b24*m.b26*
m.b35 - 224*m.b24*m.b26*m.b36 - 192*m.b24*m.b26*m.b37 - 160*m.b24*m.b26*m.b38 - 96*m.b24*m.b26*
m.b39 - 64*m.b24*m.b26*m.b40 - 96*m.b24*m.b27*m.b28 - 96*m.b24*m.b27*m.b29 - 64*m.b24*m.b27*m.b30
- 96*m.b24*m.b27*m.b31 - 96*m.b24*m.b27*m.b32 - 96*m.b24*m.b27*m.b33 - 288*m.b24*m.b27*m.b34 -
256*m.b24*m.b27*m.b35 - 224*m.b24*m.b27*m.b36 - 192*m.b24*m.b27*m.b37 - 128*m.b24*m.b27*m.b38 -
96*m.b24*m.b27*m.b39 - 64*m.b24*m.b27*m.b40 - 96*m.b24*m.b28*m.b29 - 96*m.b24*m.b28*m.b30 - 96*
m.b24*m.b28*m.b31 - 64*m.b24*m.b28*m.b32 - 96*m.b24*m.b28*m.b33 - 288*m.b24*m.b28*m.b34 - 256*
m.b24*m.b28*m.b35 - 224*m.b24*m.b28*m.b36 - 160*m.b24*m.b28*m.b37 - 128*m.b24*m.b28*m.b38 - 96*
m.b24*m.b28*m.b39 - 64*m.b24*m.b28*m.b40 - 96*m.b24*m.b29*m.b30 - 96*m.b24*m.b29*m.b31 - 96*m.b24
*m.b29*m.b32 - 96*m.b24*m.b29*m.b33 - 64*m.b24*m.b29*m.b34 - 256*m.b24*m.b29*m.b35 - 192*m.b24*
m.b29*m.b36 - 160*m.b24*m.b29*m.b37 - 128*m.b24*m.b29*m.b38 - 96*m.b24*m.b29*m.b39 - 64*m.b24*
m.b29*m.b40 - 96*m.b24*m.b30*m.b31 - 96*m.b24*m.b30*m.b32 - 96*m.b24*m.b30*m.b33 - 96*m.b24*m.b30
*m.b34 - 224*m.b24*m.b30*m.b35 - 160*m.b24*m.b30*m.b36 - 160*m.b24*m.b30*m.b37 - 128*m.b24*m.b30*
m.b38 - 96*m.b24*m.b30*m.b39 - 64*m.b24*m.b30*m.b40 - 96*m.b24*m.b31*m.b32 - 96*m.b24*m.b31*m.b33
- 64*m.b24*m.b31*m.b34 - 64*m.b24*m.b31*m.b35 - 192*m.b24*m.b31*m.b36 - 160*m.b24*m.b31*m.b37 -
96*m.b24*m.b31*m.b38 - 96*m.b24*m.b31*m.b39 - 64*m.b24*m.b31*m.b40 - 64*m.b24*m.b32*m.b33 - 64*
m.b24*m.b32*m.b34 - 64*m.b24*m.b32*m.b35 - 192*m.b24*m.b32*m.b36 - 160*m.b24*m.b32*m.b37 - 128*
m.b24*m.b32*m.b38 - 96*m.b24*m.b32*m.b39 - 32*m.b24*m.b32*m.b40 - 64*m.b24*m.b33*m.b34 - 64*m.b24
*m.b33*m.b35 - 64*m.b24*m.b33*m.b36 - 160*m.b24*m.b33*m.b37 - 128*m.b24*m.b33*m.b38 - 96*m.b24*
m.b33*m.b39 - 64*m.b24*m.b33*m.b40 - 64*m.b24*m.b34*m.b35 - 64*m.b24*m.b34*m.b36 - 160*m.b24*
m.b34*m.b37 - 128*m.b24*m.b34*m.b38 - 96*m.b24*m.b34*m.b39 - 64*m.b24*m.b34*m.b40 - 64*m.b24*
m.b35*m.b36 - 64*m.b24*m.b35*m.b37 - 128*m.b24*m.b35*m.b38 - 96*m.b24*m.b35*m.b39 - 64*m.b24*
m.b35*m.b40 - 64*m.b24*m.b36*m.b37 - 128*m.b24*m.b36*m.b38 - 96*m.b24*m.b36*m.b39 - 64*m.b24*
m.b36*m.b40 - 64*m.b24*m.b37*m.b38 - 96*m.b24*m.b37*m.b39 - 64*m.b24*m.b37*m.b40 - 96*m.b24*m.b38
*m.b39 - 64*m.b24*m.b38*m.b40 - 64*m.b24*m.b39*m.b40 - 64*m.b25*m.b26*m.b27 - 96*m.b25*m.b26*
m.b28 - 96*m.b25*m.b26*m.b29 - 96*m.b25*m.b26*m.b30 - 96*m.b25*m.b26*m.b31 - 96*m.b25*m.b26*m.b32
- 96*m.b25*m.b26*m.b33 - 288*m.b25*m.b26*m.b34 - 256*m.b25*m.b26*m.b35 - 224*m.b25*m.b26*m.b36
- 192*m.b25*m.b26*m.b37 - 160*m.b25*m.b26*m.b38 - 128*m.b25*m.b26*m.b39 - 64*m.b25*m.b26*m.b40
- 96*m.b25*m.b27*m.b28 - 64*m.b25*m.b27*m.b29 - 96*m.b25*m.b27*m.b30 - 96*m.b25*m.b27*m.b31 - 96
*m.b25*m.b27*m.b32 - 96*m.b25*m.b27*m.b33 - 288*m.b25*m.b27*m.b34 - 256*m.b25*m.b27*m.b35 - 224*
m.b25*m.b27*m.b36 - 192*m.b25*m.b27*m.b37 - 160*m.b25*m.b27*m.b38 - 96*m.b25*m.b27*m.b39 - 64*
m.b25*m.b27*m.b40 - 96*m.b25*m.b28*m.b29 - 96*m.b25*m.b28*m.b30 - 64*m.b25*m.b28*m.b31 - 96*m.b25
*m.b28*m.b32 - 96*m.b25*m.b28*m.b33 - 96*m.b25*m.b28*m.b34 - 256*m.b25*m.b28*m.b35 - 224*m.b25*
m.b28*m.b36 - 192*m.b25*m.b28*m.b37 - 128*m.b25*m.b28*m.b38 - 96*m.b25*m.b28*m.b39 - 64*m.b25*
m.b28*m.b40 - 96*m.b25*m.b29*m.b30 - 96*m.b25*m.b29*m.b31 - 96*m.b25*m.b29*m.b32 - 64*m.b25*m.b29
*m.b33 - 96*m.b25*m.b29*m.b34 - 256*m.b25*m.b29*m.b35 - 224*m.b25*m.b29*m.b36 - 160*m.b25*m.b29*
m.b37 - 128*m.b25*m.b29*m.b38 - 96*m.b25*m.b29*m.b39 - 64*m.b25*m.b29*m.b40 - 96*m.b25*m.b30*
m.b31 - 96*m.b25*m.b30*m.b32 - 96*m.b25*m.b30*m.b33 - 96*m.b25*m.b30*m.b34 - 64*m.b25*m.b30*m.b35
- 192*m.b25*m.b30*m.b36 - 160*m.b25*m.b30*m.b37 - 128*m.b25*m.b30*m.b38 - 96*m.b25*m.b30*m.b39
- 64*m.b25*m.b30*m.b40 - 96*m.b25*m.b31*m.b32 - 96*m.b25*m.b31*m.b33 - 96*m.b25*m.b31*m.b34 - 64
*m.b25*m.b31*m.b35 - 192*m.b25*m.b31*m.b36 - 128*m.b25*m.b31*m.b37 - 128*m.b25*m.b31*m.b38 - 96*
m.b25*m.b31*m.b39 - 64*m.b25*m.b31*m.b40 - 96*m.b25*m.b32*m.b33 - 64*m.b25*m.b32*m.b34 - 64*m.b25
*m.b32*m.b35 - 64*m.b25*m.b32*m.b36 - 160*m.b25*m.b32*m.b37 - 128*m.b25*m.b32*m.b38 - 64*m.b25*
m.b32*m.b39 - 64*m.b25*m.b32*m.b40 - 64*m.b25*m.b33*m.b34 - 64*m.b25*m.b33*m.b35 - 64*m.b25*m.b33
*m.b36 - 160*m.b25*m.b33*m.b37 - 128*m.b25*m.b33*m.b38 - 96*m.b25*m.b33*m.b39 - 64*m.b25*m.b33*
m.b40 - 64*m.b25*m.b34*m.b35 - 64*m.b25*m.b34*m.b36 - 64*m.b25*m.b34*m.b37 - 128*m.b25*m.b34*
m.b38 - 96*m.b25*m.b34*m.b39 - 64*m.b25*m.b34*m.b40 - 64*m.b25*m.b35*m.b36 - 64*m.b25*m.b35*m.b37
- 128*m.b25*m.b35*m.b38 - 96*m.b25*m.b35*m.b39 - 64*m.b25*m.b35*m.b40 - 64*m.b25*m.b36*m.b37 -
64*m.b25*m.b36*m.b38 - 96*m.b25*m.b36*m.b39 - 64*m.b25*m.b36*m.b40 - 64*m.b25*m.b37*m.b38 - 96*
m.b25*m.b37*m.b39 - 64*m.b25*m.b37*m.b40 - 64*m.b25*m.b38*m.b39 - 64*m.b25*m.b38*m.b40 - 64*m.b25
*m.b39*m.b40 - 64*m.b26*m.b27*m.b28 - 96*m.b26*m.b27*m.b29 - 96*m.b26*m.b27*m.b30 - 96*m.b26*
m.b27*m.b31 - 96*m.b26*m.b27*m.b32 - 96*m.b26*m.b27*m.b33 - 96*m.b26*m.b27*m.b34 - 256*m.b26*
m.b27*m.b35 - 224*m.b26*m.b27*m.b36 - 192*m.b26*m.b27*m.b37 - 160*m.b26*m.b27*m.b38 - 128*m.b26*
m.b27*m.b39 - 64*m.b26*m.b27*m.b40 - 96*m.b26*m.b28*m.b29 - 64*m.b26*m.b28*m.b30 - 96*m.b26*m.b28
*m.b31 - 96*m.b26*m.b28*m.b32 - 96*m.b26*m.b28*m.b33 - 96*m.b26*m.b28*m.b34 - 256*m.b26*m.b28*
m.b35 - 224*m.b26*m.b28*m.b36 - 192*m.b26*m.b28*m.b37 - 160*m.b26*m.b28*m.b38 - 96*m.b26*m.b28*
m.b39 - 64*m.b26*m.b28*m.b40 - 96*m.b26*m.b29*m.b30 - 96*m.b26*m.b29*m.b31 - 64*m.b26*m.b29*m.b32
- 96*m.b26*m.b29*m.b33 - 96*m.b26*m.b29*m.b34 - 96*m.b26*m.b29*m.b35 - 224*m.b26*m.b29*m.b36 -
192*m.b26*m.b29*m.b37 - 128*m.b26*m.b29*m.b38 - 96*m.b26*m.b29*m.b39 - 64*m.b26*m.b29*m.b40 - 96*
m.b26*m.b30*m.b31 - 96*m.b26*m.b30*m.b32 - 96*m.b26*m.b30*m.b33 - 64*m.b26*m.b30*m.b34 - 96*m.b26
*m.b30*m.b35 - 224*m.b26*m.b30*m.b36 - 160*m.b26*m.b30*m.b37 - 128*m.b26*m.b30*m.b38 - 96*m.b26*
m.b30*m.b39 - 64*m.b26*m.b30*m.b40 - 96*m.b26*m.b31*m.b32 - 96*m.b26*m.b31*m.b33 - 96*m.b26*m.b31
*m.b34 - 96*m.b26*m.b31*m.b35 - 32*m.b26*m.b31*m.b36 - 160*m.b26*m.b31*m.b37 - 128*m.b26*m.b31*
m.b38 - 96*m.b26*m.b31*m.b39 - 64*m.b26*m.b31*m.b40 - 96*m.b26*m.b32*m.b33 - 96*m.b26*m.b32*m.b34
- 64*m.b26*m.b32*m.b35 - 64*m.b26*m.b32*m.b36 - 160*m.b26*m.b32*m.b37 - 96*m.b26*m.b32*m.b38 -
96*m.b26*m.b32*m.b39 - 64*m.b26*m.b32*m.b40 - 64*m.b26*m.b33*m.b34 - 64*m.b26*m.b33*m.b35 - 64*
m.b26*m.b33*m.b36 - 64*m.b26*m.b33*m.b37 - 128*m.b26*m.b33*m.b38 - 96*m.b26*m.b33*m.b39 - 32*
m.b26*m.b33*m.b40 - 64*m.b26*m.b34*m.b35 - 64*m.b26*m.b34*m.b36 - 64*m.b26*m.b34*m.b37 - 128*
m.b26*m.b34*m.b38 - 96*m.b26*m.b34*m.b39 - 64*m.b26*m.b34*m.b40 - 64*m.b26*m.b35*m.b36 - 64*m.b26
*m.b35*m.b37 - 64*m.b26*m.b35*m.b38 - 96*m.b26*m.b35*m.b39 - 64*m.b26*m.b35*m.b40 - 64*m.b26*
m.b36*m.b37 - 64*m.b26*m.b36*m.b38 - 96*m.b26*m.b36*m.b39 - 64*m.b26*m.b36*m.b40 - 64*m.b26*m.b37
*m.b38 - 64*m.b26*m.b37*m.b39 - 64*m.b26*m.b37*m.b40 - 64*m.b26*m.b38*m.b39 - 64*m.b26*m.b38*
m.b40 - 64*m.b26*m.b39*m.b40 - 64*m.b27*m.b28*m.b29 - 96*m.b27*m.b28*m.b30 - 96*m.b27*m.b28*m.b31
- 96*m.b27*m.b28*m.b32 - 96*m.b27*m.b28*m.b33 - 96*m.b27*m.b28*m.b34 - 96*m.b27*m.b28*m.b35 -
224*m.b27*m.b28*m.b36 - 192*m.b27*m.b28*m.b37 - 160*m.b27*m.b28*m.b38 - 128*m.b27*m.b28*m.b39 -
64*m.b27*m.b28*m.b40 - 96*m.b27*m.b29*m.b30 - 64*m.b27*m.b29*m.b31 - 96*m.b27*m.b29*m.b32 - 96*
m.b27*m.b29*m.b33 - 96*m.b27*m.b29*m.b34 - 96*m.b27*m.b29*m.b35 - 224*m.b27*m.b29*m.b36 - 192*
m.b27*m.b29*m.b37 - 160*m.b27*m.b29*m.b38 - 96*m.b27*m.b29*m.b39 - 64*m.b27*m.b29*m.b40 - 96*
m.b27*m.b30*m.b31 - 96*m.b27*m.b30*m.b32 - 64*m.b27*m.b30*m.b33 - 96*m.b27*m.b30*m.b34 - 96*m.b27
*m.b30*m.b35 - 96*m.b27*m.b30*m.b36 - 192*m.b27*m.b30*m.b37 - 128*m.b27*m.b30*m.b38 - 96*m.b27*
m.b30*m.b39 - 64*m.b27*m.b30*m.b40 - 96*m.b27*m.b31*m.b32 - 96*m.b27*m.b31*m.b33 - 96*m.b27*m.b31
*m.b34 - 64*m.b27*m.b31*m.b35 - 96*m.b27*m.b31*m.b36 - 160*m.b27*m.b31*m.b37 - 128*m.b27*m.b31*
m.b38 - 96*m.b27*m.b31*m.b39 - 64*m.b27*m.b31*m.b40 - 96*m.b27*m.b32*m.b33 - 96*m.b27*m.b32*m.b34
- 96*m.b27*m.b32*m.b35 - 64*m.b27*m.b32*m.b36 - 32*m.b27*m.b32*m.b37 - 128*m.b27*m.b32*m.b38 -
96*m.b27*m.b32*m.b39 - 64*m.b27*m.b32*m.b40 - 96*m.b27*m.b33*m.b34 - 64*m.b27*m.b33*m.b35 - 64*
m.b27*m.b33*m.b36 - 64*m.b27*m.b33*m.b37 - 128*m.b27*m.b33*m.b38 - 64*m.b27*m.b33*m.b39 - 64*
m.b27*m.b33*m.b40 - 64*m.b27*m.b34*m.b35 - 64*m.b27*m.b34*m.b36 - 64*m.b27*m.b34*m.b37 - 64*m.b27
*m.b34*m.b38 - 96*m.b27*m.b34*m.b39 - 64*m.b27*m.b34*m.b40 - 64*m.b27*m.b35*m.b36 - 64*m.b27*
m.b35*m.b37 - 64*m.b27*m.b35*m.b38 - 96*m.b27*m.b35*m.b39 - 64*m.b27*m.b35*m.b40 - 64*m.b27*m.b36
*m.b37 - 64*m.b27*m.b36*m.b38 - 64*m.b27*m.b36*m.b39 - 64*m.b27*m.b36*m.b40 - 64*m.b27*m.b37*
m.b38 - 64*m.b27*m.b37*m.b39 - 64*m.b27*m.b37*m.b40 - 64*m.b27*m.b38*m.b39 - 64*m.b27*m.b38*m.b40
- 64*m.b27*m.b39*m.b40 - 64*m.b28*m.b29*m.b30 - 96*m.b28*m.b29*m.b31 - 96*m.b28*m.b29*m.b32 - 96
*m.b28*m.b29*m.b33 - 96*m.b28*m.b29*m.b34 - 96*m.b28*m.b29*m.b35 - 96*m.b28*m.b29*m.b36 - 192*
m.b28*m.b29*m.b37 - 160*m.b28*m.b29*m.b38 - 128*m.b28*m.b29*m.b39 - 64*m.b28*m.b29*m.b40 - 96*
m.b28*m.b30*m.b31 - 64*m.b28*m.b30*m.b32 - 96*m.b28*m.b30*m.b33 - 96*m.b28*m.b30*m.b34 - 96*m.b28
*m.b30*m.b35 - 96*m.b28*m.b30*m.b36 - 192*m.b28*m.b30*m.b37 - 160*m.b28*m.b30*m.b38 - 96*m.b28*
m.b30*m.b39 - 64*m.b28*m.b30*m.b40 - 96*m.b28*m.b31*m.b32 - 96*m.b28*m.b31*m.b33 - 64*m.b28*m.b31
*m.b34 - 96*m.b28*m.b31*m.b35 - 96*m.b28*m.b31*m.b36 - 96*m.b28*m.b31*m.b37 - 128*m.b28*m.b31*
m.b38 - 96*m.b28*m.b31*m.b39 - 64*m.b28*m.b31*m.b40 - 96*m.b28*m.b32*m.b33 - 96*m.b28*m.b32*m.b34
- 96*m.b28*m.b32*m.b35 - 64*m.b28*m.b32*m.b36 - 64*m.b28*m.b32*m.b37 - 128*m.b28*m.b32*m.b38 -
96*m.b28*m.b32*m.b39 - 64*m.b28*m.b32*m.b40 - 96*m.b28*m.b33*m.b34 - 96*m.b28*m.b33*m.b35 - 64*
m.b28*m.b33*m.b36 - 64*m.b28*m.b33*m.b37 - 32*m.b28*m.b33*m.b38 - 96*m.b28*m.b33*m.b39 - 64*m.b28
*m.b33*m.b40 - 64*m.b28*m.b34*m.b35 - 64*m.b28*m.b34*m.b36 - 64*m.b28*m.b34*m.b37 - 64*m.b28*
m.b34*m.b38 - 96*m.b28*m.b34*m.b39 - 32*m.b28*m.b34*m.b40 - 64*m.b28*m.b35*m.b36 - 64*m.b28*m.b35
*m.b37 - 64*m.b28*m.b35*m.b38 - 64*m.b28*m.b35*m.b39 - 64*m.b28*m.b35*m.b40 - 64*m.b28*m.b36*
m.b37 - 64*m.b28*m.b36*m.b38 - 64*m.b28*m.b36*m.b39 - 64*m.b28*m.b36*m.b40 - 64*m.b28*m.b37*m.b38
- 64*m.b28*m.b37*m.b39 - 64*m.b28*m.b37*m.b40 - 64*m.b28*m.b38*m.b39 - 64*m.b28*m.b38*m.b40 - 64
*m.b28*m.b39*m.b40 - 64*m.b29*m.b30*m.b31 - 96*m.b29*m.b30*m.b32 - 96*m.b29*m.b30*m.b33 - 96*
m.b29*m.b30*m.b34 - 96*m.b29*m.b30*m.b35 - 96*m.b29*m.b30*m.b36 - 96*m.b29*m.b30*m.b37 - 160*
m.b29*m.b30*m.b38 - 128*m.b29*m.b30*m.b39 - 64*m.b29*m.b30*m.b40 - 96*m.b29*m.b31*m.b32 - 64*
m.b29*m.b31*m.b33 - 96*m.b29*m.b31*m.b34 - 96*m.b29*m.b31*m.b35 - 96*m.b29*m.b31*m.b36 - 96*m.b29
*m.b31*m.b37 - 160*m.b29*m.b31*m.b38 - 96*m.b29*m.b31*m.b39 - 64*m.b29*m.b31*m.b40 - 96*m.b29*
m.b32*m.b33 - 96*m.b29*m.b32*m.b34 - 64*m.b29*m.b32*m.b35 - 96*m.b29*m.b32*m.b36 - 96*m.b29*m.b32
*m.b37 - 64*m.b29*m.b32*m.b38 - 96*m.b29*m.b32*m.b39 - 64*m.b29*m.b32*m.b40 - 96*m.b29*m.b33*
m.b34 - 96*m.b29*m.b33*m.b35 - 96*m.b29*m.b33*m.b36 - 32*m.b29*m.b33*m.b37 - 64*m.b29*m.b33*m.b38
- 96*m.b29*m.b33*m.b39 - 64*m.b29*m.b33*m.b40 - 96*m.b29*m.b34*m.b35 - 64*m.b29*m.b34*m.b36 - 64
*m.b29*m.b34*m.b37 - 64*m.b29*m.b34*m.b38 - 32*m.b29*m.b34*m.b39 - 64*m.b29*m.b34*m.b40 - 64*
m.b29*m.b35*m.b36 - 64*m.b29*m.b35*m.b37 - 64*m.b29*m.b35*m.b38 - 64*m.b29*m.b35*m.b39 - 64*m.b29
*m.b35*m.b40 - 64*m.b29*m.b36*m.b37 - 64*m.b29*m.b36*m.b38 - 64*m.b29*m.b36*m.b39 - 64*m.b29*
m.b36*m.b40 - 64*m.b29*m.b37*m.b38 - 64*m.b29*m.b37*m.b39 - 64*m.b29*m.b37*m.b40 - 64*m.b29*m.b38
*m.b39 - 64*m.b29*m.b38*m.b40 - 64*m.b29*m.b39*m.b40 - 64*m.b30*m.b31*m.b32 - 96*m.b30*m.b31*
m.b33 - 96*m.b30*m.b31*m.b34 - 96*m.b30*m.b31*m.b35 - 96*m.b30*m.b31*m.b36 - 96*m.b30*m.b31*m.b37
- 96*m.b30*m.b31*m.b38 - 128*m.b30*m.b31*m.b39 - 64*m.b30*m.b31*m.b40 - 96*m.b30*m.b32*m.b33 -
64*m.b30*m.b32*m.b34 - 96*m.b30*m.b32*m.b35 - 96*m.b30*m.b32*m.b36 - 96*m.b30*m.b32*m.b37 - 96*
m.b30*m.b32*m.b38 - 96*m.b30*m.b32*m.b39 - 64*m.b30*m.b32*m.b40 - 96*m.b30*m.b33*m.b34 - 96*m.b30
*m.b33*m.b35 - 64*m.b30*m.b33*m.b36 - 96*m.b30*m.b33*m.b37 - 64*m.b30*m.b33*m.b38 - 64*m.b30*
m.b33*m.b39 - 64*m.b30*m.b33*m.b40 - 96*m.b30*m.b34*m.b35 - 96*m.b30*m.b34*m.b36 - 64*m.b30*m.b34
*m.b37 - 32*m.b30*m.b34*m.b38 - 64*m.b30*m.b34*m.b39 - 64*m.b30*m.b34*m.b40 - 64*m.b30*m.b35*
m.b36 - 64*m.b30*m.b35*m.b37 - 64*m.b30*m.b35*m.b38 - 64*m.b30*m.b35*m.b39 - 32*m.b30*m.b35*m.b40
- 64*m.b30*m.b36*m.b37 - 64*m.b30*m.b36*m.b38 - 64*m.b30*m.b36*m.b39 - 64*m.b30*m.b36*m.b40 - 64
*m.b30*m.b37*m.b38 - 64*m.b30*m.b37*m.b39 - 64*m.b30*m.b37*m.b40 - 64*m.b30*m.b38*m.b39 - 64*
m.b30*m.b38*m.b40 - 64*m.b30*m.b39*m.b40 - 64*m.b31*m.b32*m.b33 - 96*m.b31*m.b32*m.b34 - 96*m.b31
*m.b32*m.b35 - 96*m.b31*m.b32*m.b36 - 96*m.b31*m.b32*m.b37 - 96*m.b31*m.b32*m.b38 - 96*m.b31*
m.b32*m.b39 - 64*m.b31*m.b32*m.b40 - 96*m.b31*m.b33*m.b34 - 64*m.b31*m.b33*m.b35 - 96*m.b31*m.b33
*m.b36 - 96*m.b31*m.b33*m.b37 - 96*m.b31*m.b33*m.b38 - 64*m.b31*m.b33*m.b39 - 64*m.b31*m.b33*
m.b40 - 96*m.b31*m.b34*m.b35 - 96*m.b31*m.b34*m.b36 - 64*m.b31*m.b34*m.b37 - 64*m.b31*m.b34*m.b38
- 64*m.b31*m.b34*m.b39 - 64*m.b31*m.b34*m.b40 - 96*m.b31*m.b35*m.b36 - 64*m.b31*m.b35*m.b37 - 64
*m.b31*m.b35*m.b38 - 32*m.b31*m.b35*m.b39 - 64*m.b31*m.b35*m.b40 - 64*m.b31*m.b36*m.b37 - 64*
m.b31*m.b36*m.b38 - 64*m.b31*m.b36*m.b39 - 64*m.b31*m.b36*m.b40 - 64*m.b31*m.b37*m.b38 - 64*m.b31
*m.b37*m.b39 - 64*m.b31*m.b37*m.b40 - 64*m.b31*m.b38*m.b39 - 64*m.b31*m.b38*m.b40 - 64*m.b31*
m.b39*m.b40 - 64*m.b32*m.b33*m.b34 - 96*m.b32*m.b33*m.b35 - 96*m.b32*m.b33*m.b36 - 96*m.b32*m.b33
*m.b37 - 96*m.b32*m.b33*m.b38 - 96*m.b32*m.b33*m.b39 - 64*m.b32*m.b33*m.b40 - 96*m.b32*m.b34*
m.b35 - 64*m.b32*m.b34*m.b36 - 96*m.b32*m.b34*m.b37 - 96*m.b32*m.b34*m.b38 - 64*m.b32*m.b34*m.b39
- 64*m.b32*m.b34*m.b40 - 96*m.b32*m.b35*m.b36 - 96*m.b32*m.b35*m.b37 - 32*m.b32*m.b35*m.b38 - 64
*m.b32*m.b35*m.b39 - 64*m.b32*m.b35*m.b40 - 64*m.b32*m.b36*m.b37 - 64*m.b32*m.b36*m.b38 - 64*
m.b32*m.b36*m.b39 - 32*m.b32*m.b36*m.b40 - 64*m.b32*m.b37*m.b38 - 64*m.b32*m.b37*m.b39 - 64*m.b32
*m.b37*m.b40 - 64*m.b32*m.b38*m.b39 - 64*m.b32*m.b38*m.b40 - 64*m.b32*m.b39*m.b40 - 64*m.b33*
m.b34*m.b35 - 96*m.b33*m.b34*m.b36 - 96*m.b33*m.b34*m.b37 - 96*m.b33*m.b34*m.b38 - 96*m.b33*m.b34
*m.b39 - 64*m.b33*m.b34*m.b40 - 96*m.b33*m.b35*m.b36 - 64*m.b33*m.b35*m.b37 - 96*m.b33*m.b35*
m.b38 - 64*m.b33*m.b35*m.b39 - 64*m.b33*m.b35*m.b40 - 96*m.b33*m.b36*m.b37 - 64*m.b33*m.b36*m.b38
- 32*m.b33*m.b36*m.b39 - 64*m.b33*m.b36*m.b40 - 64*m.b33*m.b37*m.b38 - 64*m.b33*m.b37*m.b39 - 64
*m.b33*m.b37*m.b40 - 64*m.b33*m.b38*m.b39 - 64*m.b33*m.b38*m.b40 - 64*m.b33*m.b39*m.b40 - 64*
m.b34*m.b35*m.b36 - 96*m.b34*m.b35*m.b37 - 96*m.b34*m.b35*m.b38 - 96*m.b34*m.b35*m.b39 - 64*m.b34
*m.b35*m.b40 - 96*m.b34*m.b36*m.b37 - 64*m.b34*m.b36*m.b38 - 64*m.b34*m.b36*m.b39 - 64*m.b34*
m.b36*m.b40 - 64*m.b34*m.b37*m.b38 - 64*m.b34*m.b37*m.b39 - 32*m.b34*m.b37*m.b40 - 64*m.b34*m.b38
*m.b39 - 64*m.b34*m.b38*m.b40 - 64*m.b34*m.b39*m.b40 - 64*m.b35*m.b36*m.b37 - 96*m.b35*m.b36*
m.b38 - 96*m.b35*m.b36*m.b39 - 64*m.b35*m.b36*m.b40 - 96*m.b35*m.b37*m.b38 - 32*m.b35*m.b37*m.b39
- 64*m.b35*m.b37*m.b40 - 64*m.b35*m.b38*m.b39 - 64*m.b35*m.b38*m.b40 - 64*m.b35*m.b39*m.b40 - 64
*m.b36*m.b37*m.b38 - 96*m.b36*m.b37*m.b39 - 64*m.b36*m.b37*m.b40 - 64*m.b36*m.b38*m.b39 - 32*
m.b36*m.b38*m.b40 - 64*m.b36*m.b39*m.b40 - 64*m.b37*m.b38*m.b39 - 64*m.b37*m.b38*m.b40 - 64*m.b37
*m.b39*m.b40 - 32*m.b38*m.b39*m.b40 + 592*m.b1*m.b2 + 584*m.b1*m.b3 + 576*m.b1*m.b4 + 568*m.b1*
m.b5 + 560*m.b1*m.b6 + 552*m.b1*m.b7 + 544*m.b1*m.b8 + 536*m.b1*m.b9 + 528*m.b1*m.b10 + 520*m.b1*
m.b11 + 512*m.b1*m.b12 + 504*m.b1*m.b13 + 496*m.b1*m.b14 + 488*m.b1*m.b15 + 480*m.b1*m.b16 + 472*
m.b1*m.b17 + 464*m.b1*m.b18 + 456*m.b1*m.b19 + 448*m.b1*m.b20 + 456*m.b1*m.b21 + 448*m.b1*m.b22
+ 440*m.b1*m.b23 + 432*m.b1*m.b24 + 424*m.b1*m.b25 + 416*m.b1*m.b26 + 408*m.b1*m.b27 + 400*m.b1*
m.b28 + 392*m.b1*m.b29 + 384*m.b1*m.b30 + 376*m.b1*m.b31 + 368*m.b1*m.b32 + 360*m.b1*m.b33 + 352*
m.b1*m.b34 + 344*m.b1*m.b35 + 336*m.b1*m.b36 + 328*m.b1*m.b37 + 320*m.b1*m.b38 + 312*m.b1*m.b39
+ 304*m.b1*m.b40 + 944*m.b2*m.b3 + 952*m.b2*m.b4 + 944*m.b2*m.b5 + 936*m.b2*m.b6 + 928*m.b2*m.b7
+ 920*m.b2*m.b8 + 912*m.b2*m.b9 + 888*m.b2*m.b10 + 880*m.b2*m.b11 + 872*m.b2*m.b12 + 864*m.b2*
m.b13 + 856*m.b2*m.b14 + 848*m.b2*m.b15 + 840*m.b2*m.b16 + 832*m.b2*m.b17 + 920*m.b2*m.b18 + 912*
m.b2*m.b19 + 888*m.b2*m.b20 + 896*m.b2*m.b21 + 888*m.b2*m.b22 + 880*m.b2*m.b23 + 856*m.b2*m.b24
+ 848*m.b2*m.b25 + 824*m.b2*m.b26 + 816*m.b2*m.b27 + 792*m.b2*m.b28 + 784*m.b2*m.b29 + 760*m.b2*
m.b30 + 752*m.b2*m.b31 + 728*m.b2*m.b32 + 720*m.b2*m.b33 + 696*m.b2*m.b34 + 688*m.b2*m.b35 + 664*
m.b2*m.b36 + 656*m.b2*m.b37 + 632*m.b2*m.b38 + 624*m.b2*m.b39 + 312*m.b2*m.b40 + 1264*m.b3*m.b4
+ 1256*m.b3*m.b5 + 1264*m.b3*m.b6 + 1256*m.b3*m.b7 + 1248*m.b3*m.b8 + 1240*m.b3*m.b9 + 1232*m.b3
*m.b10 + 1192*m.b3*m.b11 + 1184*m.b3*m.b12 + 1176*m.b3*m.b13 + 1168*m.b3*m.b14 + 1160*m.b3*m.b15
+ 1152*m.b3*m.b16 + 1160*m.b3*m.b17 + 1168*m.b3*m.b18 + 1352*m.b3*m.b19 + 1344*m.b3*m.b20 + 1320
*m.b3*m.b21 + 1344*m.b3*m.b22 + 1304*m.b3*m.b23 + 1296*m.b3*m.b24 + 1256*m.b3*m.b25 + 1248*m.b3*
m.b26 + 1208*m.b3*m.b27 + 1200*m.b3*m.b28 + 1160*m.b3*m.b29 + 1152*m.b3*m.b30 + 1112*m.b3*m.b31
+ 1104*m.b3*m.b32 + 1064*m.b3*m.b33 + 1056*m.b3*m.b34 + 1016*m.b3*m.b35 + 1008*m.b3*m.b36 + 968*
m.b3*m.b37 + 960*m.b3*m.b38 + 632*m.b3*m.b39 + 320*m.b3*m.b40 + 1536*m.b4*m.b5 + 1528*m.b4*m.b6
+ 1520*m.b4*m.b7 + 1528*m.b4*m.b8 + 1520*m.b4*m.b9 + 1512*m.b4*m.b10 + 1504*m.b4*m.b11 + 1448*
m.b4*m.b12 + 1440*m.b4*m.b13 + 1432*m.b4*m.b14 + 1424*m.b4*m.b15 + 1432*m.b4*m.b16 + 1424*m.b4*
m.b17 + 1464*m.b4*m.b18 + 1488*m.b4*m.b19 + 1768*m.b4*m.b20 + 1776*m.b4*m.b21 + 1752*m.b4*m.b22
+ 1760*m.b4*m.b23 + 1704*m.b4*m.b24 + 1696*m.b4*m.b25 + 1640*m.b4*m.b26 + 1632*m.b4*m.b27 + 1576
*m.b4*m.b28 + 1568*m.b4*m.b29 + 1512*m.b4*m.b30 + 1504*m.b4*m.b31 + 1448*m.b4*m.b32 + 1440*m.b4*
m.b33 + 1384*m.b4*m.b34 + 1376*m.b4*m.b35 + 1320*m.b4*m.b36 + 1312*m.b4*m.b37 + 968*m.b4*m.b38 +
656*m.b4*m.b39 + 328*m.b4*m.b40 + 1760*m.b5*m.b6 + 1752*m.b5*m.b7 + 1744*m.b5*m.b8 + 1736*m.b5*
m.b9 + 1744*m.b5*m.b10 + 1736*m.b5*m.b11 + 1728*m.b5*m.b12 + 1656*m.b5*m.b13 + 1648*m.b5*m.b14 +
1656*m.b5*m.b15 + 1648*m.b5*m.b16 + 1672*m.b5*m.b17 + 1680*m.b5*m.b18 + 1752*m.b5*m.b19 + 1792*
m.b5*m.b20 + 2184*m.b5*m.b21 + 2208*m.b5*m.b22 + 2168*m.b5*m.b23 + 2160*m.b5*m.b24 + 2088*m.b5*
m.b25 + 2080*m.b5*m.b26 + 2008*m.b5*m.b27 + 2000*m.b5*m.b28 + 1928*m.b5*m.b29 + 1920*m.b5*m.b30
+ 1848*m.b5*m.b31 + 1840*m.b5*m.b32 + 1768*m.b5*m.b33 + 1760*m.b5*m.b34 + 1688*m.b5*m.b35 + 1680
*m.b5*m.b36 + 1320*m.b5*m.b37 + 1008*m.b5*m.b38 + 664*m.b5*m.b39 + 336*m.b5*m.b40 + 1936*m.b6*
m.b7 + 1928*m.b6*m.b8 + 1920*m.b6*m.b9 + 1912*m.b6*m.b10 + 1904*m.b6*m.b11 + 1912*m.b6*m.b12 +
1904*m.b6*m.b13 + 1832*m.b6*m.b14 + 1824*m.b6*m.b15 + 1848*m.b6*m.b16 + 1840*m.b6*m.b17 + 1896*
m.b6*m.b18 + 1920*m.b6*m.b19 + 2024*m.b6*m.b20 + 2096*m.b6*m.b21 + 2600*m.b6*m.b22 + 2624*m.b6*
m.b23 + 2552*m.b6*m.b24 + 2544*m.b6*m.b25 + 2456*m.b6*m.b26 + 2448*m.b6*m.b27 + 2360*m.b6*m.b28
+ 2352*m.b6*m.b29 + 2264*m.b6*m.b30 + 2256*m.b6*m.b31 + 2168*m.b6*m.b32 + 2160*m.b6*m.b33 + 2072
*m.b6*m.b34 + 2064*m.b6*m.b35 + 1688*m.b6*m.b36 + 1376*m.b6*m.b37 + 1016*m.b6*m.b38 + 688*m.b6*
m.b39 + 344*m.b6*m.b40 + 2064*m.b7*m.b8 + 2056*m.b7*m.b9 + 2048*m.b7*m.b10 + 2040*m.b7*m.b11 +
2032*m.b7*m.b12 + 2040*m.b7*m.b13 + 2048*m.b7*m.b14 + 1976*m.b7*m.b15 + 1968*m.b7*m.b16 + 2008*
m.b7*m.b17 + 2016*m.b7*m.b18 + 2104*m.b7*m.b19 + 2144*m.b7*m.b20 + 2296*m.b7*m.b21 + 2400*m.b7*
m.b22 + 3000*m.b7*m.b23 + 3024*m.b7*m.b24 + 2920*m.b7*m.b25 + 2912*m.b7*m.b26 + 2808*m.b7*m.b27
+ 2800*m.b7*m.b28 + 2696*m.b7*m.b29 + 2688*m.b7*m.b30 + 2584*m.b7*m.b31 + 2576*m.b7*m.b32 + 2472
*m.b7*m.b33 + 2464*m.b7*m.b34 + 2072*m.b7*m.b35 + 1760*m.b7*m.b36 + 1384*m.b7*m.b37 + 1056*m.b7*
m.b38 + 696*m.b7*m.b39 + 352*m.b7*m.b40 + 2144*m.b8*m.b9 + 2136*m.b8*m.b10 + 2128*m.b8*m.b11 +
2136*m.b8*m.b12 + 2128*m.b8*m.b13 + 2152*m.b8*m.b14 + 2144*m.b8*m.b15 + 2088*m.b8*m.b16 + 2080*
m.b8*m.b17 + 2152*m.b8*m.b18 + 2176*m.b8*m.b19 + 2296*m.b8*m.b20 + 2368*m.b8*m.b21 + 2568*m.b8*
m.b22 + 2688*m.b8*m.b23 + 3384*m.b8*m.b24 + 3392*m.b8*m.b25 + 3272*m.b8*m.b26 + 3264*m.b8*m.b27
+ 3144*m.b8*m.b28 + 3136*m.b8*m.b29 + 3016*m.b8*m.b30 + 3008*m.b8*m.b31 + 2888*m.b8*m.b32 + 2880
*m.b8*m.b33 + 2472*m.b8*m.b34 + 2160*m.b8*m.b35 + 1768*m.b8*m.b36 + 1440*m.b8*m.b37 + 1064*m.b8*
m.b38 + 720*m.b8*m.b39 + 360*m.b8*m.b40 + 2176*m.b9*m.b10 + 2184*m.b9*m.b11 + 2176*m.b9*m.b12 +
2200*m.b9*m.b13 + 2192*m.b9*m.b14 + 2232*m.b9*m.b15 + 2224*m.b9*m.b16 + 2152*m.b9*m.b17 + 2176*
m.b9*m.b18 + 2280*m.b9*m.b19 + 2320*m.b9*m.b20 + 2488*m.b9*m.b21 + 2592*m.b9*m.b22 + 2824*m.b9*
m.b23 + 2960*m.b9*m.b24 + 3752*m.b9*m.b25 + 3744*m.b9*m.b26 + 3608*m.b9*m.b27 + 3600*m.b9*m.b28
+ 3464*m.b9*m.b29 + 3456*m.b9*m.b30 + 3320*m.b9*m.b31 + 3312*m.b9*m.b32 + 2888*m.b9*m.b33 + 2576
*m.b9*m.b34 + 2168*m.b9*m.b35 + 1840*m.b9*m.b36 + 1448*m.b9*m.b37 + 1104*m.b9*m.b38 + 728*m.b9*
m.b39 + 368*m.b9*m.b40 + 2176*m.b10*m.b11 + 2200*m.b10*m.b12 + 2192*m.b10*m.b13 + 2232*m.b10*
m.b14 + 2224*m.b10*m.b15 + 2280*m.b10*m.b16 + 2272*m.b10*m.b17 + 2200*m.b10*m.b18 + 2240*m.b10*
m.b19 + 2392*m.b10*m.b20 + 2464*m.b10*m.b21 + 2680*m.b10*m.b22 + 2800*m.b10*m.b23 + 3064*m.b10*
m.b24 + 3216*m.b10*m.b25 + 4088*m.b10*m.b26 + 4080*m.b10*m.b27 + 3928*m.b10*m.b28 + 3920*m.b10*
m.b29 + 3768*m.b10*m.b30 + 3760*m.b10*m.b31 + 3320*m.b10*m.b32 + 3008*m.b10*m.b33 + 2584*m.b10*
m.b34 + 2256*m.b10*m.b35 + 1848*m.b10*m.b36 + 1504*m.b10*m.b37 + 1112*m.b10*m.b38 + 752*m.b10*
m.b39 + 376*m.b10*m.b40 + 2144*m.b11*m.b12 + 2184*m.b11*m.b13 + 2176*m.b11*m.b14 + 2232*m.b11*
m.b15 + 2224*m.b11*m.b16 + 2296*m.b11*m.b17 + 2304*m.b11*m.b18 + 2232*m.b11*m.b19 + 2288*m.b11*
m.b20 + 2488*m.b11*m.b21 + 2608*m.b11*m.b22 + 2856*m.b11*m.b23 + 2992*m.b11*m.b24 + 3288*m.b11*
m.b25 + 3456*m.b11*m.b26 + 4408*m.b11*m.b27 + 4400*m.b11*m.b28 + 4232*m.b11*m.b29 + 4224*m.b11*
m.b30 + 3768*m.b11*m.b31 + 3456*m.b11*m.b32 + 3016*m.b11*m.b33 + 2688*m.b11*m.b34 + 2264*m.b11*
m.b35 + 1920*m.b11*m.b36 + 1512*m.b11*m.b37 + 1152*m.b11*m.b38 + 760*m.b11*m.b39 + 384*m.b11*
m.b40 + 2080*m.b12*m.b13 + 2136*m.b12*m.b14 + 2128*m.b12*m.b15 + 2200*m.b12*m.b16 + 2192*m.b12*
m.b17 + 2296*m.b12*m.b18 + 2320*m.b12*m.b19 + 2248*m.b12*m.b20 + 2336*m.b12*m.b21 + 2584*m.b12*
m.b22 + 2720*m.b12*m.b23 + 3016*m.b12*m.b24 + 3168*m.b12*m.b25 + 3496*m.b12*m.b26 + 3664*m.b12*
m.b27 + 4712*m.b12*m.b28 + 4704*m.b12*m.b29 + 4232*m.b12*m.b30 + 3920*m.b12*m.b31 + 3464*m.b12*
m.b32 + 3136*m.b12*m.b33 + 2696*m.b12*m.b34 + 2352*m.b12*m.b35 + 1928*m.b12*m.b36 + 1568*m.b12*
m.b37 + 1160*m.b12*m.b38 + 784*m.b12*m.b39 + 392*m.b12*m.b40 + 1984*m.b13*m.b14 + 2056*m.b13*
m.b15 + 2048*m.b13*m.b16 + 2136*m.b13*m.b17 + 2144*m.b13*m.b18 + 2280*m.b13*m.b19 + 2320*m.b13*
m.b20 + 2264*m.b13*m.b21 + 2384*m.b13*m.b22 + 2664*m.b13*m.b23 + 2816*m.b13*m.b24 + 3144*m.b13*
m.b25 + 3328*m.b13*m.b26 + 3688*m.b13*m.b27 + 3856*m.b13*m.b28 + 4712*m.b13*m.b29 + 4400*m.b13*
m.b30 + 3928*m.b13*m.b31 + 3600*m.b13*m.b32 + 3144*m.b13*m.b33 + 2800*m.b13*m.b34 + 2360*m.b13*
m.b35 + 2000*m.b13*m.b36 + 1576*m.b13*m.b37 + 1200*m.b13*m.b38 + 792*m.b13*m.b39 + 400*m.b13*
m.b40 + 1904*m.b14*m.b15 + 1992*m.b14*m.b16 + 1984*m.b14*m.b17 + 2104*m.b14*m.b18 + 2128*m.b14*
m.b19 + 2296*m.b14*m.b20 + 2352*m.b14*m.b21 + 2328*m.b14*m.b22 + 2464*m.b14*m.b23 + 2776*m.b14*
m.b24 + 2944*m.b14*m.b25 + 3304*m.b14*m.b26 + 3504*m.b14*m.b27 + 3688*m.b14*m.b28 + 3664*m.b14*
m.b29 + 4408*m.b14*m.b30 + 4080*m.b14*m.b31 + 3608*m.b14*m.b32 + 3264*m.b14*m.b33 + 2808*m.b14*
m.b34 + 2448*m.b14*m.b35 + 2008*m.b14*m.b36 + 1632*m.b14*m.b37 + 1208*m.b14*m.b38 + 816*m.b14*
m.b39 + 408*m.b14*m.b40 + 1856*m.b15*m.b16 + 1960*m.b15*m.b17 + 1968*m.b15*m.b18 + 2120*m.b15*
m.b19 + 2160*m.b15*m.b20 + 2360*m.b15*m.b21 + 2432*m.b15*m.b22 + 2440*m.b15*m.b23 + 2592*m.b15*
m.b24 + 2936*m.b15*m.b25 + 3120*m.b15*m.b26 + 3304*m.b15*m.b27 + 3328*m.b15*m.b28 + 3496*m.b15*
m.b29 + 3456*m.b15*m.b30 + 4088*m.b15*m.b31 + 3744*m.b15*m.b32 + 3272*m.b15*m.b33 + 2912*m.b15*
m.b34 + 2456*m.b15*m.b35 + 2080*m.b15*m.b36 + 1640*m.b15*m.b37 + 1248*m.b15*m.b38 + 824*m.b15*
m.b39 + 416*m.b15*m.b40 + 1840*m.b16*m.b17 + 1976*m.b16*m.b18 + 2000*m.b16*m.b19 + 2184*m.b16*
m.b20 + 2240*m.b16*m.b21 + 2472*m.b16*m.b22 + 2560*m.b16*m.b23 + 2600*m.b16*m.b24 + 2768*m.b16*
m.b25 + 2936*m.b16*m.b26 + 2944*m.b16*m.b27 + 3144*m.b16*m.b28 + 3168*m.b16*m.b29 + 3288*m.b16*
m.b30 + 3216*m.b16*m.b31 + 3752*m.b16*m.b32 + 3392*m.b16*m.b33 + 2920*m.b16*m.b34 + 2544*m.b16*
m.b35 + 2088*m.b16*m.b36 + 1696*m.b16*m.b37 + 1256*m.b16*m.b38 + 848*m.b16*m.b39 + 424*m.b16*
m.b40 + 1872*m.b17*m.b18 + 2040*m.b17*m.b19 + 2080*m.b17*m.b20 + 2296*m.b17*m.b21 + 2368*m.b17*
m.b22 + 2632*m.b17*m.b23 + 2736*m.b17*m.b24 + 2600*m.b17*m.b25 + 2592*m.b17*m.b26 + 2776*m.b17*
m.b27 + 2816*m.b17*m.b28 + 3016*m.b17*m.b29 + 2992*m.b17*m.b30 + 3064*m.b17*m.b31 + 2960*m.b17*
m.b32 + 3384*m.b17*m.b33 + 3024*m.b17*m.b34 + 2552*m.b17*m.b35 + 2160*m.b17*m.b36 + 1704*m.b17*
m.b37 + 1296*m.b17*m.b38 + 856*m.b17*m.b39 + 432*m.b17*m.b40 + 1952*m.b18*m.b19 + 2152*m.b18*
m.b20 + 2208*m.b18*m.b21 + 2456*m.b18*m.b22 + 2544*m.b18*m.b23 + 2632*m.b18*m.b24 + 2560*m.b18*
m.b25 + 2440*m.b18*m.b26 + 2464*m.b18*m.b27 + 2664*m.b18*m.b28 + 2720*m.b18*m.b29 + 2856*m.b18*
m.b30 + 2800*m.b18*m.b31 + 2824*m.b18*m.b32 + 2688*m.b18*m.b33 + 3000*m.b18*m.b34 + 2624*m.b18*
m.b35 + 2168*m.b18*m.b36 + 1760*m.b18*m.b37 + 1304*m.b18*m.b38 + 880*m.b18*m.b39 + 440*m.b18*
m.b40 + 2080*m.b19*m.b20 + 2312*m.b19*m.b21 + 2384*m.b19*m.b22 + 2456*m.b19*m.b23 + 2368*m.b19*
m.b24 + 2472*m.b19*m.b25 + 2432*m.b19*m.b26 + 2328*m.b19*m.b27 + 2384*m.b19*m.b28 + 2584*m.b19*
m.b29 + 2608*m.b19*m.b30 + 2680*m.b19*m.b31 + 2592*m.b19*m.b32 + 2568*m.b19*m.b33 + 2400*m.b19*
m.b34 + 2600*m.b19*m.b35 + 2208*m.b19*m.b36 + 1752*m.b19*m.b37 + 1344*m.b19*m.b38 + 888*m.b19*
m.b39 + 448*m.b19*m.b40 + 2256*m.b20*m.b21 + 2312*m.b20*m.b22 + 2208*m.b20*m.b23 + 2296*m.b20*
m.b24 + 2240*m.b20*m.b25 + 2360*m.b20*m.b26 + 2352*m.b20*m.b27 + 2264*m.b20*m.b28 + 2336*m.b20*
m.b29 + 2488*m.b20*m.b30 + 2464*m.b20*m.b31 + 2488*m.b20*m.b32 + 2368*m.b20*m.b33 + 2296*m.b20*
m.b34 + 2096*m.b20*m.b35 + 2184*m.b20*m.b36 + 1776*m.b20*m.b37 + 1320*m.b20*m.b38 + 896*m.b20*
m.b39 + 456*m.b20*m.b40 + 2080*m.b21*m.b22 + 2152*m.b21*m.b23 + 2080*m.b21*m.b24 + 2184*m.b21*
m.b25 + 2160*m.b21*m.b26 + 2296*m.b21*m.b27 + 2320*m.b21*m.b28 + 2248*m.b21*m.b29 + 2288*m.b21*
m.b30 + 2392*m.b21*m.b31 + 2320*m.b21*m.b32 + 2296*m.b21*m.b33 + 2144*m.b21*m.b34 + 2024*m.b21*
m.b35 + 1792*m.b21*m.b36 + 1768*m.b21*m.b37 + 1344*m.b21*m.b38 + 888*m.b21*m.b39 + 448*m.b21*
m.b40 + 1952*m.b22*m.b23 + 2040*m.b22*m.b24 + 2000*m.b22*m.b25 + 2120*m.b22*m.b26 + 2128*m.b22*
m.b27 + 2280*m.b22*m.b28 + 2320*m.b22*m.b29 + 2232*m.b22*m.b30 + 2240*m.b22*m.b31 + 2280*m.b22*
m.b32 + 2176*m.b22*m.b33 + 2104*m.b22*m.b34 + 1920*m.b22*m.b35 + 1752*m.b22*m.b36 + 1488*m.b22*
m.b37 + 1352*m.b22*m.b38 + 912*m.b22*m.b39 + 456*m.b22*m.b40 + 1872*m.b23*m.b24 + 1976*m.b23*
m.b25 + 1968*m.b23*m.b26 + 2104*m.b23*m.b27 + 2144*m.b23*m.b28 + 2296*m.b23*m.b29 + 2304*m.b23*
m.b30 + 2200*m.b23*m.b31 + 2176*m.b23*m.b32 + 2152*m.b23*m.b33 + 2016*m.b23*m.b34 + 1896*m.b23*
m.b35 + 1680*m.b23*m.b36 + 1464*m.b23*m.b37 + 1168*m.b23*m.b38 + 920*m.b23*m.b39 + 464*m.b23*
m.b40 + 1840*m.b24*m.b25 + 1960*m.b24*m.b26 + 1984*m.b24*m.b27 + 2136*m.b24*m.b28 + 2192*m.b24*
m.b29 + 2296*m.b24*m.b30 + 2272*m.b24*m.b31 + 2152*m.b24*m.b32 + 2080*m.b24*m.b33 + 2008*m.b24*
m.b34 + 1840*m.b24*m.b35 + 1672*m.b24*m.b36 + 1424*m.b24*m.b37 + 1160*m.b24*m.b38 + 832*m.b24*
m.b39 + 472*m.b24*m.b40 + 1856*m.b25*m.b26 + 1992*m.b25*m.b27 + 2048*m.b25*m.b28 + 2200*m.b25*
m.b29 + 2224*m.b25*m.b30 + 2280*m.b25*m.b31 + 2224*m.b25*m.b32 + 2088*m.b25*m.b33 + 1968*m.b25*
m.b34 + 1848*m.b25*m.b35 + 1648*m.b25*m.b36 + 1432*m.b25*m.b37 + 1152*m.b25*m.b38 + 840*m.b25*
m.b39 + 480*m.b25*m.b40 + 1904*m.b26*m.b27 + 2056*m.b26*m.b28 + 2128*m.b26*m.b29 + 2232*m.b26*
m.b30 + 2224*m.b26*m.b31 + 2232*m.b26*m.b32 + 2144*m.b26*m.b33 + 1976*m.b26*m.b34 + 1824*m.b26*
m.b35 + 1656*m.b26*m.b36 + 1424*m.b26*m.b37 + 1160*m.b26*m.b38 + 848*m.b26*m.b39 + 488*m.b26*
m.b40 + 1984*m.b27*m.b28 + 2136*m.b27*m.b29 + 2176*m.b27*m.b30 + 2232*m.b27*m.b31 + 2192*m.b27*
m.b32 + 2152*m.b27*m.b33 + 2048*m.b27*m.b34 + 1832*m.b27*m.b35 + 1648*m.b27*m.b36 + 1432*m.b27*
m.b37 + 1168*m.b27*m.b38 + 856*m.b27*m.b39 + 496*m.b27*m.b40 + 2080*m.b28*m.b29 + 2184*m.b28*
m.b30 + 2192*m.b28*m.b31 + 2200*m.b28*m.b32 + 2128*m.b28*m.b33 + 2040*m.b28*m.b34 + 1904*m.b28*
m.b35 + 1656*m.b28*m.b36 + 1440*m.b28*m.b37 + 1176*m.b28*m.b38 + 864*m.b28*m.b39 + 504*m.b28*
m.b40 + 2144*m.b29*m.b30 + 2200*m.b29*m.b31 + 2176*m.b29*m.b32 + 2136*m.b29*m.b33 + 2032*m.b29*
m.b34 + 1912*m.b29*m.b35 + 1728*m.b29*m.b36 + 1448*m.b29*m.b37 + 1184*m.b29*m.b38 + 872*m.b29*
m.b39 + 512*m.b29*m.b40 + 2176*m.b30*m.b31 + 2184*m.b30*m.b32 + 2128*m.b30*m.b33 + 2040*m.b30*
m.b34 + 1904*m.b30*m.b35 + 1736*m.b30*m.b36 + 1504*m.b30*m.b37 + 1192*m.b30*m.b38 + 880*m.b30*
m.b39 + 520*m.b30*m.b40 + 2176*m.b31*m.b32 + 2136*m.b31*m.b33 + 2048*m.b31*m.b34 + 1912*m.b31*
m.b35 + 1744*m.b31*m.b36 + 1512*m.b31*m.b37 + 1232*m.b31*m.b38 + 888*m.b31*m.b39 + 528*m.b31*
m.b40 + 2144*m.b32*m.b33 + 2056*m.b32*m.b34 + 1920*m.b32*m.b35 + 1736*m.b32*m.b36 + 1520*m.b32*
m.b37 + 1240*m.b32*m.b38 + 912*m.b32*m.b39 + 536*m.b32*m.b40 + 2064*m.b33*m.b34 + 1928*m.b33*
m.b35 + 1744*m.b33*m.b36 + 1528*m.b33*m.b37 + 1248*m.b33*m.b38 + 920*m.b33*m.b39 + 544*m.b33*
m.b40 + 1936*m.b34*m.b35 + 1752*m.b34*m.b36 + 1520*m.b34*m.b37 + 1256*m.b34*m.b38 + 928*m.b34*
m.b39 + 552*m.b34*m.b40 + 1760*m.b35*m.b36 + 1528*m.b35*m.b37 + 1264*m.b35*m.b38 + 936*m.b35*
m.b39 + 560*m.b35*m.b40 + 1536*m.b36*m.b37 + 1256*m.b36*m.b38 + 944*m.b36*m.b39 + 568*m.b36*m.b40
+ 1264*m.b37*m.b38 + 952*m.b37*m.b39 + 576*m.b37*m.b40 + 944*m.b38*m.b39 + 584*m.b38*m.b40 + 592
*m.b39*m.b40 - 2964*m.b1 - 5308*m.b2 - 7396*m.b3 - 9236*m.b4 - 10828*m.b5 - 12180*m.b6 - 13292*
m.b7 - 14172*m.b8 - 14820*m.b9 - 15236*m.b10 - 15420*m.b11 - 15380*m.b12 - 15116*m.b13 - 14796*
m.b14 - 14468*m.b15 - 14140*m.b16 - 13812*m.b17 - 13540*m.b18 - 13324*m.b19 - 13164*m.b20 - 13164
*m.b21 - 13324*m.b22 - 13540*m.b23 - 13812*m.b24 - 14140*m.b25 - 14468*m.b26 - 14796*m.b27 -
15116*m.b28 - 15380*m.b29 - 15420*m.b30 - 15236*m.b31 - 14820*m.b32 - 14172*m.b33 - 13292*m.b34
- 12180*m.b35 - 10828*m.b36 - 9236*m.b37 - 7396*m.b38 - 5308*m.b39 - 2964*m.b40 - m.x41 <= 0)
| 118.096638 | 120 | 0.48943 |
ace060e86487136ee02e237644469fa69d42083c | 1,793 | py | Python | multiple-languages/python/ros-cdk-sls-1.0.3/setup.py | aliyun/Resource-Orchestration-Service-Cloud-Development-K | 2b81e135002ed81cb72f7d07be7ff497ea39e2e1 | [
"Apache-2.0"
] | 15 | 2020-11-10T02:00:28.000Z | 2022-02-07T19:28:10.000Z | multiple-languages/python/ros-cdk-sls-1.0.3/setup.py | aliyun/Resource-Orchestration-Service-Cloud-Development-K | 2b81e135002ed81cb72f7d07be7ff497ea39e2e1 | [
"Apache-2.0"
] | 23 | 2021-02-02T04:37:02.000Z | 2022-03-31T06:41:06.000Z | multiple-languages/python/ros-cdk-sls-1.0.3/setup.py | aliyun/Resource-Orchestration-Service-Cloud-Development-K | 2b81e135002ed81cb72f7d07be7ff497ea39e2e1 | [
"Apache-2.0"
] | 4 | 2021-01-13T05:48:43.000Z | 2022-03-15T11:26:48.000Z | import json
import setuptools
kwargs = json.loads(
"""
{
"name": "ros-cdk-sls",
"version": "1.0.3",
"description": "Aliyun SDK Copyright (C) Alibaba Cloud Computing All rights reserved. http://www.aliyun.com",
"license": "Apache-2.0",
"url": "https://github.com/aliyun/Resource-Orchestration-Service-Cloud-Development-Kit.git",
"long_description_content_type": "text/markdown",
"author": "ROS Development Team",
"bdist_wheel": {
"universal": true
},
"project_urls": {
"Source": "https://github.com/aliyun/Resource-Orchestration-Service-Cloud-Development-Kit.git"
},
"package_dir": {
"": "src"
},
"packages": [
"ros_cdk_sls",
"ros_cdk_sls._jsii"
],
"package_data": {
"ros_cdk_sls._jsii": [
"ros-cdk-sls@1.0.3.jsii.tgz"
],
"ros_cdk_sls": [
"py.typed"
]
},
"python_requires": ">=3.6",
"install_requires": [
"constructs>=3.0.4, <4.0.0",
"jsii>=1.49.0, <2.0.0",
"publication>=0.0.3",
"ros-cdk-core>=1.0.5, <2.0.0"
],
"classifiers": [
"Intended Audience :: Developers",
"Operating System :: OS Independent",
"Programming Language :: JavaScript",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Typing :: Typed",
"License :: OSI Approved",
"Programming Language :: Python :: 3"
],
"scripts": []
}
"""
)
with open("README.md", encoding="utf8") as fp:
kwargs["long_description"] = fp.read()
setuptools.setup(**kwargs)
| 27.584615 | 113 | 0.553263 |
ace06146409e531320decade0df4e312ca2d39b1 | 23,531 | py | Python | sdk/python/pulumi_wavefront/cloud_integration_gcp_billing.py | pulumi/pulumi-wavefront | 1d199d386ee241fa2ef94553e6cae1359ec9ccf6 | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2022-02-20T09:48:33.000Z | 2022-02-20T09:48:33.000Z | sdk/python/pulumi_wavefront/cloud_integration_gcp_billing.py | pulumi/pulumi-wavefront | 1d199d386ee241fa2ef94553e6cae1359ec9ccf6 | [
"ECL-2.0",
"Apache-2.0"
] | 40 | 2020-08-12T08:37:24.000Z | 2022-03-31T15:51:17.000Z | sdk/python/pulumi_wavefront/cloud_integration_gcp_billing.py | pulumi/pulumi-wavefront | 1d199d386ee241fa2ef94553e6cae1359ec9ccf6 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
__all__ = ['CloudIntegrationGcpBillingArgs', 'CloudIntegrationGcpBilling']
@pulumi.input_type
class CloudIntegrationGcpBillingArgs:
def __init__(__self__, *,
api_key: pulumi.Input[str],
json_key: pulumi.Input[str],
project_id: pulumi.Input[str],
service: pulumi.Input[str],
additional_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
force_save: Optional[pulumi.Input[bool]] = None,
name: Optional[pulumi.Input[str]] = None,
service_refresh_rate_in_minutes: Optional[pulumi.Input[int]] = None):
"""
The set of arguments for constructing a CloudIntegrationGcpBilling resource.
:param pulumi.Input[str] api_key: API key for Google Cloud Platform (GCP)
:param pulumi.Input[str] json_key: Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
:param pulumi.Input[str] project_id: The Google Cloud Platform (GCP) Project Id
:param pulumi.Input[str] service: A value denoting which cloud service this service integrates with
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] additional_tags: A list of point tag key-values to add to every point ingested using this integration
:param pulumi.Input[bool] force_save: Forces this resource to save, even if errors are present
:param pulumi.Input[str] name: The human-readable name of this integration
:param pulumi.Input[int] service_refresh_rate_in_minutes: How often, in minutes, to refresh the service
"""
pulumi.set(__self__, "api_key", api_key)
pulumi.set(__self__, "json_key", json_key)
pulumi.set(__self__, "project_id", project_id)
pulumi.set(__self__, "service", service)
if additional_tags is not None:
pulumi.set(__self__, "additional_tags", additional_tags)
if force_save is not None:
pulumi.set(__self__, "force_save", force_save)
if name is not None:
pulumi.set(__self__, "name", name)
if service_refresh_rate_in_minutes is not None:
pulumi.set(__self__, "service_refresh_rate_in_minutes", service_refresh_rate_in_minutes)
@property
@pulumi.getter(name="apiKey")
def api_key(self) -> pulumi.Input[str]:
"""
API key for Google Cloud Platform (GCP)
"""
return pulumi.get(self, "api_key")
@api_key.setter
def api_key(self, value: pulumi.Input[str]):
pulumi.set(self, "api_key", value)
@property
@pulumi.getter(name="jsonKey")
def json_key(self) -> pulumi.Input[str]:
"""
Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
"""
return pulumi.get(self, "json_key")
@json_key.setter
def json_key(self, value: pulumi.Input[str]):
pulumi.set(self, "json_key", value)
@property
@pulumi.getter(name="projectId")
def project_id(self) -> pulumi.Input[str]:
"""
The Google Cloud Platform (GCP) Project Id
"""
return pulumi.get(self, "project_id")
@project_id.setter
def project_id(self, value: pulumi.Input[str]):
pulumi.set(self, "project_id", value)
@property
@pulumi.getter
def service(self) -> pulumi.Input[str]:
"""
A value denoting which cloud service this service integrates with
"""
return pulumi.get(self, "service")
@service.setter
def service(self, value: pulumi.Input[str]):
pulumi.set(self, "service", value)
@property
@pulumi.getter(name="additionalTags")
def additional_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
"""
A list of point tag key-values to add to every point ingested using this integration
"""
return pulumi.get(self, "additional_tags")
@additional_tags.setter
def additional_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
pulumi.set(self, "additional_tags", value)
@property
@pulumi.getter(name="forceSave")
def force_save(self) -> Optional[pulumi.Input[bool]]:
"""
Forces this resource to save, even if errors are present
"""
return pulumi.get(self, "force_save")
@force_save.setter
def force_save(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "force_save", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The human-readable name of this integration
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="serviceRefreshRateInMinutes")
def service_refresh_rate_in_minutes(self) -> Optional[pulumi.Input[int]]:
"""
How often, in minutes, to refresh the service
"""
return pulumi.get(self, "service_refresh_rate_in_minutes")
@service_refresh_rate_in_minutes.setter
def service_refresh_rate_in_minutes(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "service_refresh_rate_in_minutes", value)
@pulumi.input_type
class _CloudIntegrationGcpBillingState:
def __init__(__self__, *,
additional_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
api_key: Optional[pulumi.Input[str]] = None,
force_save: Optional[pulumi.Input[bool]] = None,
json_key: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
project_id: Optional[pulumi.Input[str]] = None,
service: Optional[pulumi.Input[str]] = None,
service_refresh_rate_in_minutes: Optional[pulumi.Input[int]] = None):
"""
Input properties used for looking up and filtering CloudIntegrationGcpBilling resources.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] additional_tags: A list of point tag key-values to add to every point ingested using this integration
:param pulumi.Input[str] api_key: API key for Google Cloud Platform (GCP)
:param pulumi.Input[bool] force_save: Forces this resource to save, even if errors are present
:param pulumi.Input[str] json_key: Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
:param pulumi.Input[str] name: The human-readable name of this integration
:param pulumi.Input[str] project_id: The Google Cloud Platform (GCP) Project Id
:param pulumi.Input[str] service: A value denoting which cloud service this service integrates with
:param pulumi.Input[int] service_refresh_rate_in_minutes: How often, in minutes, to refresh the service
"""
if additional_tags is not None:
pulumi.set(__self__, "additional_tags", additional_tags)
if api_key is not None:
pulumi.set(__self__, "api_key", api_key)
if force_save is not None:
pulumi.set(__self__, "force_save", force_save)
if json_key is not None:
pulumi.set(__self__, "json_key", json_key)
if name is not None:
pulumi.set(__self__, "name", name)
if project_id is not None:
pulumi.set(__self__, "project_id", project_id)
if service is not None:
pulumi.set(__self__, "service", service)
if service_refresh_rate_in_minutes is not None:
pulumi.set(__self__, "service_refresh_rate_in_minutes", service_refresh_rate_in_minutes)
@property
@pulumi.getter(name="additionalTags")
def additional_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
"""
A list of point tag key-values to add to every point ingested using this integration
"""
return pulumi.get(self, "additional_tags")
@additional_tags.setter
def additional_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
pulumi.set(self, "additional_tags", value)
@property
@pulumi.getter(name="apiKey")
def api_key(self) -> Optional[pulumi.Input[str]]:
"""
API key for Google Cloud Platform (GCP)
"""
return pulumi.get(self, "api_key")
@api_key.setter
def api_key(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "api_key", value)
@property
@pulumi.getter(name="forceSave")
def force_save(self) -> Optional[pulumi.Input[bool]]:
"""
Forces this resource to save, even if errors are present
"""
return pulumi.get(self, "force_save")
@force_save.setter
def force_save(self, value: Optional[pulumi.Input[bool]]):
pulumi.set(self, "force_save", value)
@property
@pulumi.getter(name="jsonKey")
def json_key(self) -> Optional[pulumi.Input[str]]:
"""
Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
"""
return pulumi.get(self, "json_key")
@json_key.setter
def json_key(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "json_key", value)
@property
@pulumi.getter
def name(self) -> Optional[pulumi.Input[str]]:
"""
The human-readable name of this integration
"""
return pulumi.get(self, "name")
@name.setter
def name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "name", value)
@property
@pulumi.getter(name="projectId")
def project_id(self) -> Optional[pulumi.Input[str]]:
"""
The Google Cloud Platform (GCP) Project Id
"""
return pulumi.get(self, "project_id")
@project_id.setter
def project_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "project_id", value)
@property
@pulumi.getter
def service(self) -> Optional[pulumi.Input[str]]:
"""
A value denoting which cloud service this service integrates with
"""
return pulumi.get(self, "service")
@service.setter
def service(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "service", value)
@property
@pulumi.getter(name="serviceRefreshRateInMinutes")
def service_refresh_rate_in_minutes(self) -> Optional[pulumi.Input[int]]:
"""
How often, in minutes, to refresh the service
"""
return pulumi.get(self, "service_refresh_rate_in_minutes")
@service_refresh_rate_in_minutes.setter
def service_refresh_rate_in_minutes(self, value: Optional[pulumi.Input[int]]):
pulumi.set(self, "service_refresh_rate_in_minutes", value)
class CloudIntegrationGcpBilling(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
additional_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
api_key: Optional[pulumi.Input[str]] = None,
force_save: Optional[pulumi.Input[bool]] = None,
json_key: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
project_id: Optional[pulumi.Input[str]] = None,
service: Optional[pulumi.Input[str]] = None,
service_refresh_rate_in_minutes: Optional[pulumi.Input[int]] = None,
__props__=None):
"""
Provides a Wavefront Cloud Integration for GCP Billing. This allows GCP Billing cloud integrations to be created,
updated, and deleted.
## Example Usage
```python
import pulumi
import pulumi_wavefront as wavefront
gcp_billing = wavefront.CloudIntegrationGcpBilling("gcpBilling",
api_key="example-api-key",
json_key=\"\"\"{...your gcp key ...}
\"\"\",
project_id="example-gcp-project")
```
## Import
GCP Billing Cloud Integrations can be imported using the `id`, e.g.
```sh
$ pulumi import wavefront:index/cloudIntegrationGcpBilling:CloudIntegrationGcpBilling gcp_billing a411c16b-3cf7-4f03-bf11-8ca05aab898d
```
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] additional_tags: A list of point tag key-values to add to every point ingested using this integration
:param pulumi.Input[str] api_key: API key for Google Cloud Platform (GCP)
:param pulumi.Input[bool] force_save: Forces this resource to save, even if errors are present
:param pulumi.Input[str] json_key: Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
:param pulumi.Input[str] name: The human-readable name of this integration
:param pulumi.Input[str] project_id: The Google Cloud Platform (GCP) Project Id
:param pulumi.Input[str] service: A value denoting which cloud service this service integrates with
:param pulumi.Input[int] service_refresh_rate_in_minutes: How often, in minutes, to refresh the service
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: CloudIntegrationGcpBillingArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Provides a Wavefront Cloud Integration for GCP Billing. This allows GCP Billing cloud integrations to be created,
updated, and deleted.
## Example Usage
```python
import pulumi
import pulumi_wavefront as wavefront
gcp_billing = wavefront.CloudIntegrationGcpBilling("gcpBilling",
api_key="example-api-key",
json_key=\"\"\"{...your gcp key ...}
\"\"\",
project_id="example-gcp-project")
```
## Import
GCP Billing Cloud Integrations can be imported using the `id`, e.g.
```sh
$ pulumi import wavefront:index/cloudIntegrationGcpBilling:CloudIntegrationGcpBilling gcp_billing a411c16b-3cf7-4f03-bf11-8ca05aab898d
```
:param str resource_name: The name of the resource.
:param CloudIntegrationGcpBillingArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(CloudIntegrationGcpBillingArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
additional_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
api_key: Optional[pulumi.Input[str]] = None,
force_save: Optional[pulumi.Input[bool]] = None,
json_key: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
project_id: Optional[pulumi.Input[str]] = None,
service: Optional[pulumi.Input[str]] = None,
service_refresh_rate_in_minutes: Optional[pulumi.Input[int]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = CloudIntegrationGcpBillingArgs.__new__(CloudIntegrationGcpBillingArgs)
__props__.__dict__["additional_tags"] = additional_tags
if api_key is None and not opts.urn:
raise TypeError("Missing required property 'api_key'")
__props__.__dict__["api_key"] = api_key
__props__.__dict__["force_save"] = force_save
if json_key is None and not opts.urn:
raise TypeError("Missing required property 'json_key'")
__props__.__dict__["json_key"] = json_key
__props__.__dict__["name"] = name
if project_id is None and not opts.urn:
raise TypeError("Missing required property 'project_id'")
__props__.__dict__["project_id"] = project_id
if service is None and not opts.urn:
raise TypeError("Missing required property 'service'")
__props__.__dict__["service"] = service
__props__.__dict__["service_refresh_rate_in_minutes"] = service_refresh_rate_in_minutes
super(CloudIntegrationGcpBilling, __self__).__init__(
'wavefront:index/cloudIntegrationGcpBilling:CloudIntegrationGcpBilling',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
additional_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
api_key: Optional[pulumi.Input[str]] = None,
force_save: Optional[pulumi.Input[bool]] = None,
json_key: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
project_id: Optional[pulumi.Input[str]] = None,
service: Optional[pulumi.Input[str]] = None,
service_refresh_rate_in_minutes: Optional[pulumi.Input[int]] = None) -> 'CloudIntegrationGcpBilling':
"""
Get an existing CloudIntegrationGcpBilling resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] additional_tags: A list of point tag key-values to add to every point ingested using this integration
:param pulumi.Input[str] api_key: API key for Google Cloud Platform (GCP)
:param pulumi.Input[bool] force_save: Forces this resource to save, even if errors are present
:param pulumi.Input[str] json_key: Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
:param pulumi.Input[str] name: The human-readable name of this integration
:param pulumi.Input[str] project_id: The Google Cloud Platform (GCP) Project Id
:param pulumi.Input[str] service: A value denoting which cloud service this service integrates with
:param pulumi.Input[int] service_refresh_rate_in_minutes: How often, in minutes, to refresh the service
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = _CloudIntegrationGcpBillingState.__new__(_CloudIntegrationGcpBillingState)
__props__.__dict__["additional_tags"] = additional_tags
__props__.__dict__["api_key"] = api_key
__props__.__dict__["force_save"] = force_save
__props__.__dict__["json_key"] = json_key
__props__.__dict__["name"] = name
__props__.__dict__["project_id"] = project_id
__props__.__dict__["service"] = service
__props__.__dict__["service_refresh_rate_in_minutes"] = service_refresh_rate_in_minutes
return CloudIntegrationGcpBilling(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="additionalTags")
def additional_tags(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
"""
A list of point tag key-values to add to every point ingested using this integration
"""
return pulumi.get(self, "additional_tags")
@property
@pulumi.getter(name="apiKey")
def api_key(self) -> pulumi.Output[str]:
"""
API key for Google Cloud Platform (GCP)
"""
return pulumi.get(self, "api_key")
@property
@pulumi.getter(name="forceSave")
def force_save(self) -> pulumi.Output[Optional[bool]]:
"""
Forces this resource to save, even if errors are present
"""
return pulumi.get(self, "force_save")
@property
@pulumi.getter(name="jsonKey")
def json_key(self) -> pulumi.Output[str]:
"""
Private key for a Google Cloud Platform (GCP) service account within your project.
The account must be at least granted Monitoring Viewer permissions. This key must be in the JSON format generated by GCP.
"""
return pulumi.get(self, "json_key")
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
"""
The human-readable name of this integration
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="projectId")
def project_id(self) -> pulumi.Output[str]:
"""
The Google Cloud Platform (GCP) Project Id
"""
return pulumi.get(self, "project_id")
@property
@pulumi.getter
def service(self) -> pulumi.Output[str]:
"""
A value denoting which cloud service this service integrates with
"""
return pulumi.get(self, "service")
@property
@pulumi.getter(name="serviceRefreshRateInMinutes")
def service_refresh_rate_in_minutes(self) -> pulumi.Output[Optional[int]]:
"""
How often, in minutes, to refresh the service
"""
return pulumi.get(self, "service_refresh_rate_in_minutes")
| 44.065543 | 162 | 0.653393 |
ace061c775d36e294e4577e3c167669d5eba9374 | 1,160 | py | Python | setup.py | paradxum/django-macaddress | c223dc8c79555d2265789c4d13667036cfbd7bd8 | [
"BSD-3-Clause"
] | null | null | null | setup.py | paradxum/django-macaddress | c223dc8c79555d2265789c4d13667036cfbd7bd8 | [
"BSD-3-Clause"
] | 1 | 2020-08-05T09:29:52.000Z | 2020-08-05T09:29:52.000Z | setup.py | paradxum/django-macaddress | c223dc8c79555d2265789c4d13667036cfbd7bd8 | [
"BSD-3-Clause"
] | 1 | 2020-08-05T09:11:10.000Z | 2020-08-05T09:11:10.000Z | import os
from setuptools import setup, find_packages
version = "1.6.0"
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-macaddress",
version = version,
url = 'http://github.com/tubaman/django-macaddress',
license = 'BSD',
description = "MAC address model and form fields for Django apps.",
long_description = read('README.rst'),
author = 'Ryan Nowakowski',
author_email = 'tubaman@fattuba.com',
maintainer = 'Arun Karunagath',
maintainer_email = 'the1.arun@gmail.com',
packages = ['macaddress', 'macaddress.tests'],
install_requires = ['netaddr'],
tests_require = ['Django'],
test_suite="runtests.runtests",
classifiers = [
'Development Status :: 5 - Production/Stable',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Topic :: Internet :: WWW/HTTP',
]
)
| 31.351351 | 71 | 0.631034 |
ace061e28fea70c0ba08876a3282aae6c5fc93ea | 4,239 | py | Python | sixweeks/sixweeks/settings/settings.py | Chrysus/sixweeks | 4550a63aa74a621c236baa3c01136b94b944e7e9 | [
"MIT"
] | null | null | null | sixweeks/sixweeks/settings/settings.py | Chrysus/sixweeks | 4550a63aa74a621c236baa3c01136b94b944e7e9 | [
"MIT"
] | null | null | null | sixweeks/sixweeks/settings/settings.py | Chrysus/sixweeks | 4550a63aa74a621c236baa3c01136b94b944e7e9 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
#
# Copyright 2017 Chrysus
# Licensed under MIT (https://github.com/Chrysus/sixweeks/blob/master/LICENSE)
"""
Django settings for sixweeks_project project.
Generated by 'django-admin startproject' using Django 1.11.3.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = # '[ *****YOU MUST REPLACE THIS COMMENT WITH A SECRET KEY STRING***** ]'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False
ALLOWED_HOSTS = ['[***** REPLACE THIS WITH YOUR IP or DOMAIN *****]', '[***** REPLACE THIS WITH YOUR IP or DOMAIN *****]:80', '[***** REPLACE THIS WITH YOUR IP or DOMAIN *****]:443']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'django_extensions',
'widget_tweaks',
# custom apps
'sixweeks.apps.SixweeksConfig',
'accounts.apps.AccountsConfig',
'days.apps.DaysConfig',
'exercises.apps.ExercisesConfig',
'meals.apps.MealsConfig',
'points.apps.PointsConfig',
'mock.apps.MockConfig',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
# Custom Additions
'detect.middleware.UserAgentDetectionMiddleware',
]
ROOT_URLCONF = 'sixweeks.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates'),],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'sixweeks.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases
DATABASES = {
# ***** REPLACE THIS WITH YOUR OWN DB INFO *****
'''
'default': {
'ENGINE': '',
'NAME': '',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
'''
}
# Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
AUTH_USER_MODEL = 'sixweeks.User'
# Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = '/static/'
LOGIN_URL = '/sixweeks/accounts/sign-in-sign-up/'
# Security
#SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
os.environ['wsgi.urlscheme'] = 'https'
| 26.660377 | 182 | 0.681765 |
ace062804d36c22b093e64f7a908f640fb101fb4 | 32,801 | py | Python | gumbi/aggregation.py | JohnGoertz/Gumbi | 7a7df9bf97bf10cdf5dc8af36026dba578e161c9 | [
"Apache-2.0"
] | 34 | 2021-11-29T11:40:52.000Z | 2022-03-10T09:08:59.000Z | gumbi/aggregation.py | JohnGoertz/Gumbi | 7a7df9bf97bf10cdf5dc8af36026dba578e161c9 | [
"Apache-2.0"
] | 13 | 2021-12-30T17:07:34.000Z | 2022-02-18T18:46:37.000Z | gumbi/aggregation.py | JohnGoertz/Gumbi | 7a7df9bf97bf10cdf5dc8af36026dba578e161c9 | [
"Apache-2.0"
] | null | null | null | from __future__ import annotations # Necessary for self-type annotations until Python >3.10
import pickle
import warnings
from collections import namedtuple
from dataclasses import dataclass
from abc import ABC, abstractmethod
import numpy as np
import pandas as pd
from scipy.special import logit, expit
from .utils import skip
__all__ = ['Standardizer', 'TidyData', 'WideData', 'DataSet']
class Standardizer(dict):
r"""Container for dict of mean (μ) and variance (σ2) for every parameter.
:class:`Standardizer` objects allow transformation and normalization of datasets. The main methods are :meth:`stdz`,
which attempts to coerce the values of a given variable to a standard normal distribution (`z-scores`), and its
complement :meth:`unstdz`. The steps are
.. math::
\mathbf{\text{tidy}} \rightarrow \text{transform} \rightarrow \text{mean-center} \rightarrow \text{scale}
\rightarrow \mathbf{\text{tidy.z}}
For example, reaction `rate` must clearly be strictly positive, so we use a `log` transformation so that it behaves
as a normally-distributed random variable. We then mean-center and scale this transformed value to obtain `z-scores`
indicating how similar a given estimate is to all the other estimates we've observed. `Standardizer` stores the
transforms and population mean and variance for every parameter, allowing us to convert back and forth
between natural space (:math:`rate`), transformed space (:math:`\text{ln}\; rate`), and standardized space
(:math:`\left( \text{ln}\; rate - \mu_{\text{ln}\; rate} \right)/\sigma_{\text{ln}\; rate}`).
Typically, a :class:`Standardizer` will be constructed from a dataframe (:meth:`from_DataFrame`),
but the individual means and variances can be provided at instantiation as well. Note, however,
that these should be the mean/std of the *transformed* variable. For example, if `r` should be treated as
log-normal with a natural-space mean of 1 and variance of 0.1, the right way to instantiate the class
would be `Standardizer(d={'μ': 0, 'σ2': 0.1}, log_vars=['d'])`.
Notes
-----
:class:`Standardizer` is just a `dictionary <https://docs.python.org/3/tutorial/datastructures.html#dictionaries>`_
with some extra methods and defaults, so standard dictionary methods like :meth:`dict.update` still work.
Parameters
----------
log_vars: list, optional
List of input and output variables to be treated as log-normal.
logit_vars: list, optional
List of input and output variables to be treated as logit-normal.
**kwargs
Mean and variance of each variable as a dictionary, e.g. d={'μ': 0, 'σ2': 0.1}
Examples
--------
>>> import numpy as np
>>> import pandas as pd
>>> from gumbi import Standardizer
>>> stdzr = Standardizer(x={'μ': 1, 'σ2': 0.1}, d={'μ': 0, 'σ2': 0.1}, log_vars=['d'])
Transforming and standardizing a single parameter:
>>> stdzr.transform('x', μ=1)
1
>>> stdzr.stdz('x', 1)
0.0
>>> stdzr.unstdz('x', 0)
1.0
>>> stdzr.stdz('x', 1+0.1**0.5)
1.0 # approximately
>>> stdzr.unstdz('x', 1)
1.316227766016838
>>> stdzr.stdz('d', 1)
0.0
>>> stdzr.stdz('d', np.exp(0.1**0.5))
1.0 # approximately
Transforming and standardizing a distribution:
>>> stdzr.transform('x', μ=1., σ2=0.1)
(1, 0.1)
>>> stdzr.stdz('x', 1, 0.1)
(0.0, 1.0)
>>> stdzr.stdz('d', 1, 0.1)
(0.0, 1.0)
>>> stdzr.transform('d', 1, 0.1)
(0.0, 0.1)
Standardizing a series:
>>> x_series = pd.Series(np.arange(1,5), name='x')
>>> stdzr.stdz(x_series)
0 0.000000
1 3.162278
2 6.324555
3 9.486833
Name: x, dtype: float64
>>> r_series = pd.Series(np.arange(1,5), name='d')
>>> stdzr.stdz(r_series)
0 0.000000
1 2.191924
2 3.474117
3 4.383848
Name: r, dtype: float64
"""
# TODO: Standardizer: make transform suggestions based on provided tidy? e.g., all>0 -> log/exp
def __init__(self, log_vars=None, logit_vars=None, **kwargs):
self.validate(kwargs)
for name, stats in kwargs.items():
if 'σ2' not in stats:
stats['σ2'] = stats['σ']**2
del stats['σ']
super().__init__(**kwargs)
self._transforms = {var: [skip, skip] for var in kwargs.keys()}
if log_vars is not None:
log_vars = [log_vars] if isinstance(log_vars, str) else log_vars
if not isinstance(log_vars, list):
raise TypeError('log_vars must be a list or str')
self._transforms.update({var: [np.log, np.exp] for var in log_vars})
if logit_vars is not None:
logit_vars = [logit_vars] if isinstance(logit_vars, str) else logit_vars
if not isinstance(logit_vars, list):
raise TypeError('logit_vars must be a list or str')
self._transforms.update({var: [logit, expit] for var in logit_vars})
self._log_vars = log_vars if log_vars is not None else []
self._logit_vars = logit_vars if logit_vars is not None else []
def __or__(self, __dct) -> Standardizer:
# new_dct = super().__or__(__dct) # Use when Python>=3.9
new_dct = {**self, **__dct}
stdzr = Standardizer(**new_dct)
if isinstance(__dct, Standardizer):
stdzr.transforms = {**self.transforms, **__dct.transforms} # Fix once Python >= 3.9
else:
stdzr.transforms = self.transforms
return stdzr
def __ror__(self, __dct) -> Standardizer:
new_dct = super().__ror__(__dct)
stdzr = Standardizer(**new_dct)
stdzr.transforms = self.transforms
return stdzr
def __repr__(self):
summary = '\n\t'.join([
f'Standardizer:',
f'log_vars: {self.log_vars}',
f'logit_vars: {self.logit_vars}',
]) + '\n\n' + str({**self})
return summary
@property
def log_vars(self) -> list[str]:
"""List of log-normal variables"""
return self._log_vars
@log_vars.setter
def log_vars(self, var_list):
var_list = [var_list] if isinstance(var_list, str) else var_list
if not isinstance(var_list, list):
raise TypeError('log_vars must be a list or str')
self._log_vars = var_list
self._transforms.update({var: [np.log, np.exp] for var in var_list}) # Fix once Python >= 3.9
@property
def logit_vars(self) -> list[str]:
"""List of logit-normal variables"""
return self._logit_vars
@logit_vars.setter
def logit_vars(self, var_list):
var_list = [var_list] if isinstance(var_list, str) else var_list
if not isinstance(var_list, list):
raise TypeError('logit_vars must be a list or str')
self._logit_vars = var_list
self._transforms.update({var: [logit, expit] for var in var_list}) # Fix once Python >= 3.9
@property
def transforms(self) -> dict:
"""Collection of forward and reverse transform functions for each variable"""
return self._transforms
@transforms.setter
def transforms(self, dct) -> dict:
self._transforms = dct
self._log_vars = [v for v, lst in dct.items() if lst[0] is np.log]
self._logit_vars = [v for v, lst in dct.items() if lst[0] is logit]
@classmethod
def validate(cls, dct: dict):
"""Ensures provided dictionary has all required attributes"""
assert all('μ' in sub.keys() for sub in dct.values())
assert all(('σ' in sub.keys() or 'σ2' in sub.keys()) for sub in dct.values())
@classmethod
def from_DataFrame(cls, df: pd.DataFrame, log_vars=None, logit_vars=None):
"""Construct from wide-form DataFrame"""
float_columns = df.dtypes[df.dtypes == 'float64'].index.to_list()
new = cls(log_vars=log_vars, logit_vars=logit_vars)
dct = (df[float_columns]
.apply(new.transform)
.agg([np.mean, np.var])
.rename(index={"mean": "μ", "var": "σ2"})
.to_dict()
)
return new | dct
def transform(self, name: str | pd.Series, μ: float = None, σ2: float = None) -> float | tuple | pd.Series:
"""Transforms a parameter, distribution, or Series
Parameters
----------
name: str or pd.Series
Name of parameter. If a Series is supplied, the name of the series must be the parameter name.
μ: float, optional
Value of parameter or mean of parameter distribution. Only optional if first argument is a Series.
σ2: float, optional
Variance of parameter distribution.
Returns
-------
float, tuple, or pd.Series
Transformed parameter, (mean, variance) of untransformed distribution, or untransformed Series
"""
if isinstance(name, pd.Series):
series=name
return self._transform_value(series.name, series)
elif μ is None:
raise ValueError('μ cannot be None')
if σ2 is None:
return self._transform_value(name, μ)
else:
return self._transform_dist(name, μ, σ2)
def untransform(self, name: str | pd.Series, μ: float = None, σ2: float = None) -> float | tuple | pd.Series:
"""Untransforms a parameter, distribution, or Series
Parameters
----------
name: str or pd.Series
Name of parameter. If a Series is supplied, the name of the series must be the parameter name.
μ: float, optional
Value of parameter or mean of parameter distribution. Only optional if first argument is a Series.
σ2: float, optional
Variance of parameter distribution.
Returns
-------
float, tuple, or pd.Series
Untransformed parameter, (mean, variance) of untransformed distribution, or untransformed Series
"""
if isinstance(name, pd.Series):
series = name
return self._untransform_value(series.name, series)
if σ2 is None:
return self._untransform_value(name, μ)
else:
return self._untransform_dist(name, μ, σ2)
def stdz(self, name: str | pd.Series, μ: float = None, σ2: float = None) -> float | tuple | pd.Series:
"""Transforms, mean-centers, and scales a parameter, distribution, or Series
Parameters
----------
name: str or pd.Series
Name of parameter. If a Series is supplied, the name of the series must be the parameter name.
μ: float, optional
Value of parameter or mean of parameter distribution. Only optional if first argument is a Series.
σ2: float, optional
Variance of parameter distribution.
Returns
-------
float, tuple, or pd.Series
Standardized parameter, (mean, variance) of standardized distribution, or standardized Series
"""
if isinstance(name, pd.Series):
series = name
return self._stdz_value(series.name, series)
if σ2 is None:
return self._stdz_value(name, μ)
else:
return self._stdz_dist(name, μ, σ2)
def unstdz(self, name: str | pd.Series, μ: float = None, σ2: float = None) -> float | tuple | pd.Series:
"""Untransforms, un-centers, and un-scales a parameter, distribution, or Series
Parameters
----------
name: str or pd.Series
Name of parameter. If a Series is supplied, the name of the series must be the parameter name.
μ: float, optional
Value of parameter or mean of parameter distribution. Only optional if first argument is a Series.
σ2: float, optional
Variance of parameter distribution.
Returns
-------
float, tuple, or pd.Series
Unstandardized parameter, (mean, variance) of unstandardized distribution, or unstandardized Series
"""
if isinstance(name, pd.Series):
series = name
return self._unstdz_value(series.name, series)
if σ2 is None:
return self._unstdz_value(name, μ)
else:
return self._unstdz_dist(name, μ, σ2)
def _transform_value(self, name: str, x: float) -> float:
ftransform = self.transforms.get(name, [skip, skip])[0]
return ftransform(x)
def _untransform_value(self, name: str, x: float) -> float:
rtransform = self.transforms.get(name, [skip, skip])[1]
x_ = rtransform(x)
return x_
def _stdz_value(self, name: str, x: float) -> float:
x_ = self.transform(name, x)
μ = self.get(name, {'μ': 0})['μ']
σ2 = self.get(name, {'σ2': 1})['σ2']
σ = np.sqrt(σ2)
return (x_ - μ) / σ
def _unstdz_value(self, name: str, z: float) -> float:
μ = self.get(name, {'μ': 0})['μ']
σ2 = self.get(name, {'σ2': 1})['σ2']
σ = np.sqrt(σ2)
x_ = z * σ + μ
return self.untransform(name, x_)
@property
def mean_transforms(self):
"""Function that transforms the mean of a distribution.
These transform's should follow scipy's conventions such that a distribution can be defined in the given
space by passing (loc=μ, scale=σ2**0.5). For a lognormal variable, an RV defined as ``lognorm(loc=μ,
scale=σ2**0.5)`` in "natural" space is equivalent to ``norm(loc=np.log(μ), scale=σ2**0.5)`` in log space,
so this transform should return ``np.log(μ)`` when converting from natural to log space, and ``np.exp(μ)``
when converting from log to natural space. Similarly for a logit-normal variable, an RV defined as
``logitnorm(loc=μ, scale=σ2**0.5))`` in natural space is equivalent to ``norm(loc=logit(μ), scale=σ2**0.5)``
in logit space, so this transform should return ``logit(μ)`` when converting from natural to logit space,
and ``expit(μ)`` when converting from logit to natural space.
"""
# Forward and reverse transform for each variable type
transforms = {skip: [lambda μ, σ2: μ,
lambda μ, σ2: μ],
# Note these are no longer strictly mean and variance. They are defined to be compatible with
# scipy.stats.lognormal definition
np.log: [lambda μ, σ2: np.log(μ),
lambda μ, σ2: np.exp(μ)],
logit: [lambda μ, σ2: logit(μ),
lambda μ, σ2: expit(μ)]
}
return transforms
@property
def var_transforms(self):
"""Function that transforms the variance of a distribution.
These transform's should follow scipy's conventions such that a distribution can be defined in the given
space by passing (loc=μ, scale=σ2**0.5). Accordingly, since both log-normal and logit-normal variables are
defined in terms of the scale (standard deviation) in their respective transformed spaces, this function
simply returns the variance unchanged in these cases.
"""
# Forward and reverse transform for each variable type
transforms = {skip: [lambda μ, σ2: σ2,
lambda μ, σ2: σ2],
np.log: [lambda μ, σ2: σ2,
lambda μ, σ2: σ2],
logit: [lambda μ, σ2: σ2,
lambda μ, σ2: σ2]
}
return transforms
def _transform_dist(self, name: str, mean: float, var: float) -> tuple:
f_transform = self.transforms.get(name, [skip, skip])[0]
f_mean_transform = self.mean_transforms[f_transform][0]
f_var_transform = self.var_transforms[f_transform][0]
mean_ = f_mean_transform(mean, var)
var_ = f_var_transform(mean, var)
return mean_, var_
def _untransform_dist(self, name: str, mean: float, var: float) -> tuple:
f_transform = self.transforms.get(name, [skip, skip])[0]
r_mean_transform = self.mean_transforms[f_transform][1]
r_var_transform = self.var_transforms[f_transform][1]
mean_ = r_mean_transform(mean, var)
var_ = r_var_transform(mean, var)
return mean_, var_
def _stdz_dist(self, name: str, mean: float, var: float) -> tuple:
mean_, var_ = self.transform(name, mean, var)
μ = self.get(name, {'μ': 0})['μ']
σ2 = self.get(name, {'σ2': 1})['σ2']
σ = np.sqrt(σ2)
mean_z = (mean_ - μ) / σ
var_z = var_ / σ2
return mean_z, var_z
def _unstdz_dist(self, name: str, z_mean: float, z_var: float) -> tuple:
μ = self.get(name, {'μ': 0})['μ']
σ2 = self.get(name, {'σ2': 1})['σ2']
σ = np.sqrt(σ2)
mean_ = z_mean * σ + μ
var_ = z_var * σ2
mean, var = self.untransform(name, mean_, var_)
return mean, var
@dataclass
class MetaFrame(pd.DataFrame, ABC):
"""Abstract Base Class for :class:`WideData` and :class:`TidyData`."""
df: pd.DataFrame
outputs: list
log_vars: list = None
logit_vars: list = None
names_column: str = 'Variable'
values_column: str = 'Value'
stdzr: Standardizer = None
_metadata = ['df', 'outputs', 'log_vars', 'logit_vars', 'names_column', 'values_column', 'stdzr']
def __post_init__(self):
super(MetaFrame, self).__init__(self.df)
if self.stdzr is None:
self.stdzr = Standardizer.from_DataFrame(self.df, log_vars=self.log_vars, logit_vars=self.logit_vars)
else:
self.log_vars = self.stdzr.log_vars
self.logit_vars = self.stdzr.logit_vars
del self.df
def __repr__(self):
cls = self.__class__.__name__
df_repr = super(MetaFrame, self).__repr__()
summary = '\n\t'.join([
f'{cls}:',
f'outputs: {self.outputs}',
f'inputs: {self.inputs}',
]) + '\n\n' + df_repr
return summary
@property
@abstractmethod
def z(self) -> pd.DataFrame:
"""Standardized data values."""
pass
@property
@abstractmethod
def t(self) -> pd.DataFrame:
"""Transformed data values."""
pass
@property
def specs(self) -> dict:
"""Provides keyword arguments for easy instantiation of a similar object."""
return dict(outputs=self.outputs, names_column=self.names_column, values_column=self.values_column,
stdzr=self.stdzr, log_vars=self.log_vars, logit_vars=self.logit_vars)
@property
def inputs(self) -> list[str]:
"""Columns of dataframe not contained in :attr:`outputs`."""
return [col for col in self.columns if col not in self.outputs]
@property
def float_inputs(self) -> list[str]:
"""Columns of dataframe with "float64" dtype."""
return [col for col in self.inputs if self[col].dtype == 'float64']
@classmethod
def _wide_to_tidy_(cls, wide, outputs, names_column='Variable', values_column='Value'):
inputs = [col for col in wide.columns if col not in outputs]
tidy = wide.melt(id_vars=inputs, value_vars=outputs, var_name=names_column,
value_name=values_column)
return tidy
@classmethod
def _tidy_to_wide_(cls, tidy, names_column='Variable', values_column='Value'):
inputs = [col for col in tidy.columns if col not in [names_column, values_column]]
wide = (tidy
.pivot(index=inputs, columns=names_column, values=values_column)
.reset_index()
.rename_axis(columns=None)
)
return wide
class WideData(MetaFrame):
"""Container for wide-form tabular data, allowing simple access to standardized and/or transformed values.
Note that :class:`WideData` is instantiated with a **wide-form** dataframe. This class is not intended to be
instantiated directly, use :class:`DataSet` instead. :class:`WideData` subclasses pandas' DataFrame,
which everyone says is a bad idea, so be prepared for unexpected behavior if instantiated directly. Namely, in-place
modifications return a :class:`WideData` type correctly, but slices return a `pd.DataFrame` type.
Parameters
----------
data: pd.DataFrame
A wide-form dataframe.
outputs: list
Columns of `data` to be treated as outputs.
names_column: str, default 'Variable'
Name to be used in tidy view for column containing output names.
values_column: str, default 'Value'
Name to be used in tidy view for column containing output values.
log_vars: list, optional
List of input and output variables to be treated as log-normal. Ignored if `stdzr` is supplied.
logit_vars: list, optional
List of input and output variables to be treated as logit-normal. Ignored if `stdzr` is supplied.
stdzr: Standardizer, optional
An :class:`Standardizer` instance. If not supplied, one will be created automatically.
"""
@property
def z(self) -> pd.DataFrame:
"""Standardized data values."""
df_ = self.copy()
cols = self.outputs + self.float_inputs
df_[cols] = df_[cols].apply(self.stdzr.stdz)
return df_
@property
def t(self) -> pd.DataFrame:
"""Transformed data values."""
df_ = self.copy()
cols = self.outputs + self.float_inputs
df_[cols] = df_[cols].apply(self.stdzr.transform)
return df_
def to_tidy(self) -> TidyData:
"""Converts to TidyData"""
tidy = TidyData(self, **self.specs)
return tidy
@classmethod
def from_tidy(cls, tidy, outputs=None, names_column='Variable', values_column='Value',
stdzr=None, log_vars=None, logit_vars=None):
"""Constructs `WideData` from a tidy-form dataframe. See :class:`WideData` for explanation of arguments."""
outputs = outputs if outputs is not None else list(tidy[names_column].unique())
wide = cls._tidy_to_wide_(tidy, names_column=names_column, values_column=values_column)
return cls(wide, outputs=outputs, names_column=names_column, values_column=values_column,
stdzr=stdzr, log_vars=log_vars, logit_vars=logit_vars)
class TidyData(MetaFrame):
"""Container for tidy-form tabular data, allowing simple access to standardized and/or transformed values.
Note that :class:`TidyData` is instantiated with a **wide-form** dataframe. This class is not intended to be
instantiated directly, use :class:`DataSet` instead. :class:`TidyData` subclasses pandas' DataFrame,
which everyone says is a bad idea, so be prepared for unexpected behavior if instantiated directly. Namely, in-place
modifications return a :class:`TidyData` type correctly, but slices return a `pd.DataFrame` type.
Parameters
----------
data: pd.DataFrame
A wide-form dataframe.
outputs: list
Columns of `data` to be treated as outputs.
names_column: str, default 'Variable'
Name to be used in tidy view for column containing output names.
values_column: str, default 'Value'
Name to be used in tidy view for column containing output values.
log_vars: list, optional
List of input and output variables to be treated as log-normal. Ignored if `stdzr` is supplied.
logit_vars: list, optional
List of input and output variables to be treated as logit-normal. Ignored if `stdzr` is supplied.
stdzr: Standardizer, optional
An :class:`Standardizer` instance. If not supplied, one will be created automatically.
"""
def __post_init__(self):
tidy = self._wide_to_tidy_(self.df, outputs=self.outputs, names_column=self.names_column,
values_column=self.values_column)
self.df = tidy
super(TidyData, self).__post_init__()
@property
def z(self) -> pd.DataFrame:
"""Standardized data values."""
wide = self.to_wide()
specs = dict(outputs=self.outputs, names_column=self.names_column, values_column=self.values_column)
wd = WideData(wide, **specs, stdzr=self.stdzr)
z = self._wide_to_tidy_(wd.z, **specs)
return z
@property
def t(self) -> pd.DataFrame:
"""Transformed data values."""
wide = self.to_wide()
specs = dict(outputs=self.outputs, names_column=self.names_column, values_column=self.values_column)
wd = WideData(wide, **specs, stdzr=self.stdzr)
z = self._wide_to_tidy_(wd.t, **specs)
return z
def to_wide(self) -> WideData:
"""Converts to WideData"""
wide_df = self._tidy_to_wide_(self, names_column=self.names_column, values_column=self.values_column)
wide = WideData(wide_df, **self.specs)
return wide
@dataclass
class DataSet:
"""Container for tabular data, allowing simple access to standardized values and wide or tidy dataframe formats.
:class:`DataSet` is instantiated with a **wide-form** dataframe, with all outputs of a given observation in a
single row, but allows easy access to the corresponding **tidy** dataframe, with each output in a separate row (
the :meth:`from_tidy` also allows construction from tidy data`). The titles of the tidy-form columns for the
output names and their values are supplied at instantiation, defaulting to "Variable" and "Value". For example,
say we have an observation at position (x,y) with measurements of i, j, and k. The wide-form dataframe would have
one column for each of x, y, i, j, and k, while the tidy-form dataframe would have a column for each of x and y,
a "Variable" column where each row contains either "i", "j", or "k" as strings, and a "Value" column containing
the corresponding measurement. Wide data is more space-efficient and perhaps more intuitive to construct and
inspect, while tidy data more clearly distinguishes inputs and outputs. These views are accessible through the
:attr:`wide` and :attr:`tidy` attributes as instances of :class:`WideData` and :class:`TidyData`, respectively.
As a container for :class:`WideData` and :class:`TidyData`, this class also provides simple access to
standardized values of the data through `wide.z` and `tidy.z` or transformed values through `wide.t` and
`tidy.t`. A :class:`Standardizer` instance can be supplied as a keyword argument, otherwise one will be
constructed automatically from the supplied dataframe with the supplied values of `log_vars` and `logit_vars`.
Unlike :class:`WideData` and :class:`TidyData`, the :attr:`wide` and :attr:`tidy` attributes of a *DataSet* can
be altered and sliced while retaining their functionality, with a cursory integrity check. The
:class:`Standardizer` instance can be updated with :meth:`update_stdzr`, for example following manipulation of
the data or alteration of :attr:`log_vars` and :attr:`logit_vars`.
Parameters
----------
data: pd.DataFrame
A wide-form dataframe. See class method :meth:`from_tidy` for instantiation from tidy data.
outputs: list
Columns of `data` to be treated as outputs.
names_column: str, default 'Variable'
Name to be used in tidy view for column containing output names.
values_column: str, default 'Value'
Name to be used in tidy view for column containing output values.
log_vars: list, optional
List of input and output variables to be treated as log-normal. Ignored if `stdzr` is supplied.
logit_vars: list, optional
List of input and output variables to be treated as logit-normal. Ignored if `stdzr` is supplied.
stdzr: Standardizer, optional
An :class:`Standardizer` instance. If not supplied, one will be created automatically.
Examples
--------
>>> df = pd.read_pickle(test_data / 'estimates_test_data.pkl')
>>> ds = DataSet.from_tidy(df, names_column='Parameter', log_vars=['Y', 'c', 'b'], logit_vars=['X', 'e'])
>>> ds
DataSet:
wide: [66 rows x 13 columns]
tidy: [396 rows x 9 columns]
outputs: ['e', 'f', 'b', 'c', 'a', 'd']
inputs: ['Code', 'Target', 'Y', 'X', 'Reaction', 'lg10_Z', 'Metric']
>>> ds.wide = ds.wide.drop(range(0,42,2))
DataSet:
wide: [45 rows x 13 columns]
tidy: [270 rows x 9 columns]
outputs: ['e', 'f', 'b', 'c', 'a', 'd']
inputs: ['Code', 'Target', 'Y', 'X', 'Reaction', 'lg10_Z', 'Metric']
>>> ds.tidy.z # tidy-form dataframe with standardized values
>>> ds.wide.z # wide-form dataframe with standardized values
"""
data: pd.DataFrame
outputs: list
names_column: str = 'Variable'
values_column: str = 'Value'
log_vars: list = None
logit_vars: list = None
stdzr: Standardizer = None
def __post_init__(self):
if self.stdzr is None:
self.stdzr = Standardizer.from_DataFrame(self.wide, log_vars=self.log_vars, logit_vars=self.logit_vars)
else:
self.log_vars = self.stdzr.log_vars
self.logit_vars = self.stdzr.logit_vars
def __repr__(self):
wide_shape = '[{0} rows x {1} columns]'.format(*self.wide.shape)
tidy_shape = '[{0} rows x {1} columns]'.format(*self.tidy.shape)
summary = '\n\t'.join([
'DataSet:',
f'wide: {wide_shape}',
f'tidy: {tidy_shape}',
f'outputs: {self.outputs}',
f'inputs: {self.inputs}',
])
return summary
@property
def specs(self):
"""Provides keyword arguments for easy instantiation of a similar :class:`DataSet`."""
return dict(outputs=self.outputs, names_column=self.names_column, values_column=self.values_column,
stdzr=self.stdzr, log_vars=self.log_vars, logit_vars=self.logit_vars)
@property
def inputs(self):
"""Columns of dataframe not contained in :attr:`outputs`."""
return [col for col in self.wide.columns if col not in self.outputs]
@property
def float_inputs(self):
"""Columns of dataframe with "float64" dtype."""
return [col for col in self.inputs if self.wide[col].dtype == 'float64']
@property
def wide(self) -> WideData:
"""Wide-form view of data"""
return WideData(self.data, **self.specs)
@wide.setter
def wide(self, wide_df: pd.DataFrame):
assert any([output in wide_df.columns for output in self.outputs]), \
f'Dataframe must have at least one of outputs {self.outputs}'
self.data = wide_df
@property
def tidy(self) -> TidyData:
"""Tidy-form view of data"""
return TidyData(self.data, **self.specs)
@tidy.setter
def tidy(self, tidy_df: pd.DataFrame):
assert all([col in tidy_df.columns for col in [self.names_column, self.values_column]]), \
f'Dataframe must have both columns {[self.names_column, self.values_column]}'
self.wide = WideData.from_tidy(tidy_df, **self.specs)
@classmethod
def from_tidy(cls, tidy, outputs=None, names_column='Variable', values_column='Value',
stdzr=None, log_vars=None, logit_vars=None):
"""Constructs a `DataSet` from a tidy-form dataframe. See :class:`DataSet` for explanation of arguments."""
assert all([col in tidy.columns for col in [names_column, values_column]]), \
f'Dataframe must have both columns {[names_column, values_column]}'
specs = dict(outputs=outputs, names_column=names_column, values_column=values_column,
stdzr=stdzr, log_vars=log_vars, logit_vars=logit_vars)
wide = WideData.from_tidy(tidy, **specs)
return cls(wide, **wide.specs)
@classmethod
def from_wide(cls, wide, outputs=None, names_column='Variable', values_column='Value',
stdzr=None, log_vars=None, logit_vars=None):
"""Constructs a `DataSet` from a wide-form dataframe. See :class:`DataSet` for explanation of arguments."""
return cls(wide, outputs=outputs, names_column=names_column, values_column=values_column, stdzr=stdzr,
log_vars=log_vars, logit_vars=logit_vars)
def update_stdzr(self):
"""Updates internal :class:`Standardizer` with current data, :attr:`log_vars`, and :attr:`logit_vars`."""
self.stdzr.update(Standardizer.from_DataFrame(self.wide, log_vars=self.log_vars, logit_vars=self.logit_vars)) # Fix once Python >= 3.9
| 42.323871 | 143 | 0.631688 |
ace062e481a4eed4f5ff46f0d4e548464f5d7405 | 4,040 | py | Python | examples/small_parallel_enja_pytorch.py | awesome-archive/lineflow | 1b753a1c2d5d3c7b369c6dd7f20e836c90d43407 | [
"MIT"
] | 1 | 2020-01-07T05:26:56.000Z | 2020-01-07T05:26:56.000Z | examples/small_parallel_enja_pytorch.py | arita37/lineflow | 1b753a1c2d5d3c7b369c6dd7f20e836c90d43407 | [
"MIT"
] | null | null | null | examples/small_parallel_enja_pytorch.py | arita37/lineflow | 1b753a1c2d5d3c7b369c6dd7f20e836c90d43407 | [
"MIT"
] | null | null | null | from collections import Counter
from functools import partial
import random
import torch
from torch.utils.data import DataLoader
from torch.utils.data import Sampler, BatchSampler
from tqdm import tqdm
import lineflow as lf
import lineflow.datasets as lfds
PAD_TOKEN = '<pad>'
UNK_TOKEN = '<unk>'
START_TOKEN = '<s>'
END_TOKEN = '</s>'
IGNORE_INDEX = -100
class SortedSampler(Sampler):
def __init__(self, dataset, sort_key, sorting_size=None):
self._num_samples = len(dataset)
self._dataset = dataset
self._sort_key = sort_key
self._sorting_size = sorting_size or self._num_samples
def __iter__(self):
chunk = []
for i, x in enumerate(self._dataset):
chunk.append((i, self._sort_key(x)))
if len(chunk) == self._sorting_size:
chunk.sort(key=lambda x: x[1])
yield from (i for i, _ in chunk)
chunk = []
if chunk:
chunk.sort(key=lambda x: x[1])
yield from (i for i, _ in chunk)
def __len__(self):
return self._num_samples
class RandomBatchSampler(BatchSampler):
def __init__(self, sampler, batch_size, drop_last, pool_size=100):
super().__init__(sampler, batch_size, drop_last)
self.pool_size = pool_size
def __iter__(self):
bucket = []
batch = []
for index in self.sampler:
batch.append(index)
if len(batch) == self.batch_size:
bucket.append(batch)
batch = []
if len(bucket) == self.pool_size:
random.shuffle(bucket)
yield from bucket
bucket = []
if len(bucket) > 0:
yield from bucket
if len(batch) > 0 and not self.drop_last:
yield batch
def to_dict(x):
return {'en': x[0], 'ja': x[1]}
@lf.apply('en')
@lf.apply('ja')
def tokenize(x):
return [START_TOKEN] + x.split() + [END_TOKEN]
def build_vocab(tokens):
counter = Counter(tokens)
words, _ = zip(*counter.most_common())
words = [PAD_TOKEN, UNK_TOKEN] + list(words)
return dict(zip(words, range(len(words))))
def get_indexer(key, token_to_index, unk_index):
def indexer(token_to_index, unk_index, x):
return [token_to_index.get(token, unk_index) for token in x]
return lf.apply(key)(partial(indexer, token_to_index, unk_index))
def collate(pad_index, batch):
src, tgt = zip(*((x['en'], x['ja']) for x in batch))
src_max_length = max(len(x) for x in src)
tgt_max_length = max(len(y) for y in tgt)
padded_src = [x + [pad_index] * (src_max_length - len(x)) for x in src]
padded_tgt = [y + [IGNORE_INDEX] * (tgt_max_length - len(y)) for y in tgt]
return torch.LongTensor(padded_src), torch.LongTensor(padded_tgt)
if __name__ == '__main__':
print('Reading...')
train = lfds.SmallParallelEnJa('train').map(to_dict)
validation = lfds.SmallParallelEnJa('dev').map(to_dict)
train = train.map(tokenize)
validation = validation.map(tokenize)
en_tokens = (train + validation).flat_map(lambda x: x['en'])
ja_tokens = (train + validation).flat_map(lambda x: x['ja'])
print('Building vocabulary...')
en_token_to_index = build_vocab(en_tokens)
ja_token_to_index = build_vocab(ja_tokens)
en_unk_index = en_token_to_index[UNK_TOKEN]
ja_unk_index = ja_token_to_index[UNK_TOKEN]
en_indexer = get_indexer('en', en_token_to_index, en_unk_index)
ja_indexer = get_indexer('ja', ja_token_to_index, ja_unk_index)
train = train.map(en_indexer).map(ja_indexer)
pad_index = en_token_to_index[PAD_TOKEN]
batch_size = 64
pool_size = 100
loader = DataLoader(
train,
batch_sampler=RandomBatchSampler(
SortedSampler(train, lambda x: - len(x['en']), batch_size * pool_size),
batch_size, False, pool_size),
num_workers=4,
collate_fn=partial(collate, pad_index))
for batch in tqdm(loader):
...
del loader
| 28.857143 | 83 | 0.634901 |
ace0644143a8c7a26ea43deda0f96145b7d880f9 | 2,103 | py | Python | apps/programming/powershell/__init__.py | donno2048/Rosehip | a4348ad92c93c6b4d12fcd610e979d1d1cf53c81 | [
"MIT"
] | 4 | 2020-09-07T06:10:44.000Z | 2021-12-29T21:57:02.000Z | apps/programming/powershell/__init__.py | donno2048/Rosehip | a4348ad92c93c6b4d12fcd610e979d1d1cf53c81 | [
"MIT"
] | 2 | 2020-07-19T14:07:37.000Z | 2021-11-22T18:23:00.000Z | apps/programming/powershell/__init__.py | donno2048/Rosehip | a4348ad92c93c6b4d12fcd610e979d1d1cf53c81 | [
"MIT"
] | null | null | null | import sys;import io;import os;os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide";import pygame;from io import StringIO;pygame.init();font = pygame.font.Font(None, 32);clock = pygame.time.Clock();input_box = pygame.Rect(100, 100, 140, 32);out_box=pygame.Rect(100,200, 140, 32);from pygame_gui.elements import UIWindow;from pygame_gui.elements import UITextBox;from pygame_gui.elements import UITextEntryLine;from pygame_gui.elements import UITextBox;import pygame_gui;import concurrent.futures
class power(UIWindow):
def __init__(self, pos, manager):super().__init__(pygame.Rect(pos, (400, 300)), manager, window_display_title="powershell", object_id="#powershell",resizable=True);self.textbox = pygame_gui.elements.UITextBox("",relative_rect=pygame.Rect(0, 0, 368, 200),manager=manager,container=self,anchors={"left": "left","right": "right","top": "top","bottom": "bottom",},);self.input = pygame_gui.elements.UITextEntryLine(relative_rect=pygame.Rect(0, -35, 368, 30),manager=manager,container=self,anchors={"left": "left","right": "right","top": "bottom","bottom": "bottom",},);self.text='';self.manager=manager;self.input.focus()
def process_event(self, event):
super().process_event(event)
if event.type == pygame.KEYUP and event.key == pygame.K_RETURN:os.chdir(os.path.dirname(os.path.abspath(__file__)));open('py.ps1','w').writelines(self.input.get_text().split('|'));self.text+='<br>'+os.popen('powershell.exe -file py.ps1').read().replace('\n','<br>');os.system('del py.ps1');self.input.kill();self.textbox.kill();self.textbox = pygame_gui.elements.UITextBox(self.text,relative_rect=pygame.Rect(0, 0, 368, 200),manager=self.manager,container=self,anchors={"left": "left","right": "right","top": "top","bottom": "bottom",},);self.input = pygame_gui.elements.UITextEntryLine(relative_rect=pygame.Rect(0, -35, 368, 30),manager=self.manager,container=self,anchors={"left": "left","right": "right","top": "bottom","bottom": "bottom",},);self.input.focus()
def load(manager, params):pos = params[0] if params is not None and len(params) > 0 else (100,100);power(pos, manager)
| 262.875 | 772 | 0.734189 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.